# Generated by the protocol buffer compiler.  DO NOT EDIT!
# sources: api.proto
# plugin: python-betterproto
# This file has been @generated

from dataclasses import dataclass
from datetime import datetime
from typing import (
    TYPE_CHECKING,
    AsyncIterator,
    Dict,
    List,
    Optional,
)

import betterproto
import grpclib
from betterproto.grpc.grpclib_server import ServiceBase

from .. import common as _common__


if TYPE_CHECKING:
    import grpclib.server
    from betterproto.grpc.grpclib_client import MetadataLike
    from grpclib.metadata import Deadline


class MarketStatus(betterproto.Enum):
    MS_UNKNOWN = 0
    MS_ONLINE = 1


class Side(betterproto.Enum):
    S_UNKNOWN = 0
    S_BID = 1
    S_ASK = 2


class OrderStatus(betterproto.Enum):
    OS_UNKNOWN = 0
    OS_OPEN = 1
    OS_PARTIAL_FILL = 2
    OS_CANCELLED = 3
    OS_FILLED = 4


class Direction(betterproto.Enum):
    D_ASCENDING = 0
    D_DESCENDING = 1


class SubmitStrategy(betterproto.Enum):
    P_UKNOWN = 0
    P_SUBMIT_ALL = 1
    P_ABORT_ON_FIRST_ERROR = 2
    P_WAIT_FOR_CONFIRMATION = 3


class Step(betterproto.Enum):
    _0 = 0
    _1 = 1
    _2 = 2
    _3 = 3


class Project(betterproto.Enum):
    P_UNKNOWN = 0
    P_ALL = 1
    P_JUPITER = 2
    P_RAYDIUM = 3
    P_SERUM = 4
    P_OPENBOOK = 5


@dataclass(eq=False, repr=False)
class GetMarketsRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetMarketsResponse(betterproto.Message):
    markets: Dict[str, "Market"] = betterproto.map_field(
        1, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE
    )


@dataclass(eq=False, repr=False)
class Market(betterproto.Message):
    market: str = betterproto.string_field(1)
    status: "MarketStatus" = betterproto.enum_field(2)
    address: str = betterproto.string_field(3)
    base_mint: str = betterproto.string_field(4)
    quoted_mint: str = betterproto.string_field(5)
    base_decimals: int = betterproto.int64_field(6)
    quote_decimals: int = betterproto.int64_field(7)
    project: "Project" = betterproto.enum_field(8)


@dataclass(eq=False, repr=False)
class GetTickersRequest(betterproto.Message):
    market: str = betterproto.string_field(1)
    project: "Project" = betterproto.enum_field(2)


@dataclass(eq=False, repr=False)
class GetTickersResponse(betterproto.Message):
    tickers: List["Ticker"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class Ticker(betterproto.Message):
    market: str = betterproto.string_field(1)
    market_address: str = betterproto.string_field(2)
    bid: float = betterproto.double_field(3)
    bid_size: float = betterproto.double_field(4)
    ask: float = betterproto.double_field(5)
    ask_size: float = betterproto.double_field(6)
    project: "Project" = betterproto.enum_field(7)


@dataclass(eq=False, repr=False)
class GetKlineRequest(betterproto.Message):
    market: str = betterproto.string_field(1)
    from_: datetime = betterproto.message_field(2)
    to: datetime = betterproto.message_field(3)
    resolution: str = betterproto.string_field(4)
    limit: int = betterproto.uint32_field(5)


@dataclass(eq=False, repr=False)
class GetKlineResponse(betterproto.Message):
    market: str = betterproto.string_field(1)
    timestamp: datetime = betterproto.message_field(2)
    candles: List["Candle"] = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class Candle(betterproto.Message):
    start_time: datetime = betterproto.message_field(1)
    update_time: datetime = betterproto.message_field(2)
    open: float = betterproto.double_field(3)
    close: float = betterproto.double_field(4)
    low: float = betterproto.double_field(5)
    high: float = betterproto.double_field(6)
    amount: float = betterproto.double_field(7)
    volume: float = betterproto.double_field(8)
    count: float = betterproto.double_field(9)


@dataclass(eq=False, repr=False)
class GetOrderbookRequest(betterproto.Message):
    market: str = betterproto.string_field(1)
    limit: int = betterproto.uint32_field(2)
    project: "Project" = betterproto.enum_field(3)


@dataclass(eq=False, repr=False)
class GetOrderbooksRequest(betterproto.Message):
    markets: List[str] = betterproto.string_field(1)
    limit: int = betterproto.uint32_field(2)
    project: "Project" = betterproto.enum_field(3)


@dataclass(eq=False, repr=False)
class GetOrderbookResponse(betterproto.Message):
    market: str = betterproto.string_field(1)
    market_address: str = betterproto.string_field(2)
    bids: List["OrderbookItem"] = betterproto.message_field(3)
    asks: List["OrderbookItem"] = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class OrderbookItem(betterproto.Message):
    price: float = betterproto.double_field(1)
    size: float = betterproto.double_field(2)
    order_id: str = betterproto.string_field(3)
    client_order_id: int = betterproto.uint64_field(4)
    owner_address: str = betterproto.string_field(5)


@dataclass(eq=False, repr=False)
class GetMarketDepthRequest(betterproto.Message):
    market: str = betterproto.string_field(1)
    limit: int = betterproto.uint32_field(2)
    project: "Project" = betterproto.enum_field(3)


@dataclass(eq=False, repr=False)
class GetMarketDepthsRequest(betterproto.Message):
    markets: List[str] = betterproto.string_field(1)
    limit: int = betterproto.uint32_field(2)
    project: "Project" = betterproto.enum_field(3)


@dataclass(eq=False, repr=False)
class GetMarketDepthResponse(betterproto.Message):
    market: str = betterproto.string_field(1)
    market_address: str = betterproto.string_field(2)
    bids: List["MarketDepthItem"] = betterproto.message_field(3)
    asks: List["MarketDepthItem"] = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class MarketDepthItem(betterproto.Message):
    price: float = betterproto.double_field(1)
    size: float = betterproto.double_field(2)


@dataclass(eq=False, repr=False)
class GetTradesRequest(betterproto.Message):
    market: str = betterproto.string_field(1)
    limit: int = betterproto.uint32_field(2)
    project: "Project" = betterproto.enum_field(3)


@dataclass(eq=False, repr=False)
class GetTradesResponse(betterproto.Message):
    trades: List["Trade"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class Trade(betterproto.Message):
    side: "Side" = betterproto.enum_field(1)
    size: float = betterproto.double_field(2)
    fill_price: float = betterproto.double_field(3)
    order_id: str = betterproto.string_field(4)
    is_maker: bool = betterproto.bool_field(5)
    address: str = betterproto.string_field(6)
    fee_or_rebate: float = betterproto.double_field(7)
    order_price: float = betterproto.double_field(8)


@dataclass(eq=False, repr=False)
class GetServerTimeRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetServerTimeResponse(betterproto.Message):
    timestamp: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetAccountBalanceRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetAccountBalanceResponse(betterproto.Message):
    tokens: List["TokenBalance"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class TokenBalance(betterproto.Message):
    symbol: str = betterproto.string_field(1)
    token_mint: str = betterproto.string_field(2)
    settled_amount: float = betterproto.double_field(3)
    unsettled_amount: float = betterproto.double_field(4)
    open_orders_amount: float = betterproto.double_field(5)


@dataclass(eq=False, repr=False)
class GetTokenAccountsRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetTokenAccountsResponse(betterproto.Message):
    accounts: List["TokenAccount"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class TokenAccount(betterproto.Message):
    symbol: str = betterproto.string_field(1)
    token_mint: str = betterproto.string_field(2)
    token_account: str = betterproto.string_field(3)
    amount: float = betterproto.double_field(4)


@dataclass(eq=False, repr=False)
class PostOrderRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    payer_address: str = betterproto.string_field(2)
    market: str = betterproto.string_field(3)
    side: "Side" = betterproto.enum_field(4)
    type: List["_common__.OrderType"] = betterproto.enum_field(5)
    amount: float = betterproto.double_field(6)
    price: float = betterproto.double_field(7)
    open_orders_address: str = betterproto.string_field(8)
    client_order_id: int = betterproto.uint64_field(9)
    compute_limit: int = betterproto.uint32_field(10)
    compute_price: int = betterproto.uint64_field(11)
    tip: Optional[int] = betterproto.uint64_field(12, optional=True)
    project: "Project" = betterproto.enum_field(13)


@dataclass(eq=False, repr=False)
class PostReplaceOrderRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    payer_address: str = betterproto.string_field(2)
    market: str = betterproto.string_field(3)
    side: "Side" = betterproto.enum_field(4)
    type: List["_common__.OrderType"] = betterproto.enum_field(5)
    amount: float = betterproto.double_field(6)
    price: float = betterproto.double_field(7)
    open_orders_address: str = betterproto.string_field(8)
    client_order_id: int = betterproto.uint64_field(9)
    order_id: str = betterproto.string_field(10)
    compute_limit: int = betterproto.uint32_field(11)
    compute_price: int = betterproto.uint64_field(12)
    tip: Optional[int] = betterproto.uint64_field(13, optional=True)
    project: "Project" = betterproto.enum_field(14)


@dataclass(eq=False, repr=False)
class PostOrderResponse(betterproto.Message):
    transaction: "TransactionMessage" = betterproto.message_field(1)
    open_orders_address: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class PostCancelOrderRequest(betterproto.Message):
    order_id: str = betterproto.string_field(1)
    side: "Side" = betterproto.enum_field(2)
    market_address: str = betterproto.string_field(3)
    owner_address: str = betterproto.string_field(4)
    open_orders_address: str = betterproto.string_field(5)
    compute_limit: int = betterproto.uint32_field(6)
    compute_price: int = betterproto.uint64_field(7)
    tip: Optional[int] = betterproto.uint64_field(8, optional=True)
    project: "Project" = betterproto.enum_field(9)


@dataclass(eq=False, repr=False)
class PostCancelByClientOrderIdRequest(betterproto.Message):
    client_order_id: int = betterproto.uint64_field(1)
    market_address: str = betterproto.string_field(2)
    owner_address: str = betterproto.string_field(3)
    open_orders_address: str = betterproto.string_field(4)
    compute_limit: int = betterproto.uint32_field(5)
    compute_price: int = betterproto.uint64_field(6)
    tip: Optional[int] = betterproto.uint64_field(7, optional=True)
    project: "Project" = betterproto.enum_field(8)


@dataclass(eq=False, repr=False)
class PostCancelOrderResponse(betterproto.Message):
    transaction: "TransactionMessage" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class PostCancelAllRequest(betterproto.Message):
    market: str = betterproto.string_field(1)
    owner_address: str = betterproto.string_field(2)
    open_orders_addresses: List[str] = betterproto.string_field(3)
    compute_limit: int = betterproto.uint32_field(4)
    compute_price: int = betterproto.uint64_field(5)
    tip: Optional[int] = betterproto.uint64_field(6, optional=True)
    project: "Project" = betterproto.enum_field(7)


@dataclass(eq=False, repr=False)
class TransactionMessage(betterproto.Message):
    content: str = betterproto.string_field(1)
    is_cleanup: bool = betterproto.bool_field(2)


@dataclass(eq=False, repr=False)
class TransactionMessageV2(betterproto.Message):
    content: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class PostCancelAllResponse(betterproto.Message):
    transactions: List["TransactionMessage"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class PostSettleRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    market: str = betterproto.string_field(2)
    base_token_wallet: str = betterproto.string_field(3)
    quote_token_wallet: str = betterproto.string_field(4)
    open_orders_address: str = betterproto.string_field(5)
    compute_limit: int = betterproto.uint32_field(6)
    compute_price: int = betterproto.uint64_field(7)
    project: "Project" = betterproto.enum_field(8)


@dataclass(eq=False, repr=False)
class PostSettleResponse(betterproto.Message):
    transaction: "TransactionMessage" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class Settlement(betterproto.Message):
    symbol: str = betterproto.string_field(1)
    unsettled: float = betterproto.double_field(2)
    amount: float = betterproto.double_field(3)


@dataclass(eq=False, repr=False)
class GetOrdersRequest(betterproto.Message):
    market: str = betterproto.string_field(1)
    status: "OrderStatus" = betterproto.enum_field(2)
    side: "Side" = betterproto.enum_field(3)
    types: List["_common__.OrderType"] = betterproto.enum_field(4)
    from_: datetime = betterproto.message_field(5)
    limit: int = betterproto.uint32_field(6)
    direction: "Direction" = betterproto.enum_field(7)
    address: str = betterproto.string_field(8)
    open_orders_address: str = betterproto.string_field(9)
    project: "Project" = betterproto.enum_field(10)


@dataclass(eq=False, repr=False)
class GetOrdersResponse(betterproto.Message):
    orders: List["Order"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class Order(betterproto.Message):
    order_id: str = betterproto.string_field(1)
    market: str = betterproto.string_field(2)
    side: "Side" = betterproto.enum_field(3)
    types: List["_common__.OrderType"] = betterproto.enum_field(4)
    price: float = betterproto.double_field(5)
    remaining_size: float = betterproto.double_field(6)
    created_at: datetime = betterproto.message_field(7)
    client_order_id: str = betterproto.string_field(8)
    open_order_account: str = betterproto.string_field(9)


@dataclass(eq=False, repr=False)
class GetOrderStatusStreamRequest(betterproto.Message):
    market: str = betterproto.string_field(1)
    owner_address: str = betterproto.string_field(2)
    project: "Project" = betterproto.enum_field(3)


@dataclass(eq=False, repr=False)
class GetOrderStatusStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    order_info: "GetOrderStatusResponse" = betterproto.message_field(2)
    timestamp: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetOrderStatusResponse(betterproto.Message):
    market: str = betterproto.string_field(1)
    open_order_address: str = betterproto.string_field(2)
    order_id: str = betterproto.string_field(3)
    client_order_id: int = betterproto.uint64_field(4)
    quantity_released: float = betterproto.float_field(5)
    quantity_remaining: float = betterproto.float_field(6)
    fill_price: float = betterproto.float_field(7)
    side: "Side" = betterproto.enum_field(8)
    order_status: "OrderStatus" = betterproto.enum_field(9)
    order_price: float = betterproto.float_field(10)


@dataclass(eq=False, repr=False)
class PostSubmitRequest(betterproto.Message):
    transaction: "TransactionMessage" = betterproto.message_field(1)
    skip_pre_flight: bool = betterproto.bool_field(2)
    front_running_protection: Optional[bool] = betterproto.bool_field(3, optional=True)
    tip: Optional[int] = betterproto.uint64_field(4, optional=True)
    use_staked_rp_cs: Optional[bool] = betterproto.bool_field(6, optional=True)
    fast_best_effort: Optional[bool] = betterproto.bool_field(7, optional=True)
    allow_back_run: Optional[bool] = betterproto.bool_field(8, optional=True)
    revenue_address: Optional[str] = betterproto.string_field(9, optional=True)
    sniping: Optional[bool] = betterproto.bool_field(10, optional=True)


@dataclass(eq=False, repr=False)
class PostSubmitPaladinRequest(betterproto.Message):
    transaction: "TransactionMessageV2" = betterproto.message_field(1)
    revert_protection: Optional[bool] = betterproto.bool_field(2, optional=True)


@dataclass(eq=False, repr=False)
class PostSubmitRequestEntry(betterproto.Message):
    transaction: "TransactionMessage" = betterproto.message_field(1)
    skip_pre_flight: bool = betterproto.bool_field(2)


@dataclass(eq=False, repr=False)
class PostSubmitBatchRequest(betterproto.Message):
    entries: List["PostSubmitRequestEntry"] = betterproto.message_field(1)
    submit_strategy: "SubmitStrategy" = betterproto.enum_field(2)
    use_bundle: Optional[bool] = betterproto.bool_field(3, optional=True)
    front_running_protection: Optional[bool] = betterproto.bool_field(4, optional=True)


@dataclass(eq=False, repr=False)
class PostSubmitBatchResponseEntry(betterproto.Message):
    signature: str = betterproto.string_field(1)
    error: str = betterproto.string_field(2)
    submitted: bool = betterproto.bool_field(3)


@dataclass(eq=False, repr=False)
class PostSubmitBatchResponse(betterproto.Message):
    transactions: List["PostSubmitBatchResponseEntry"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class PostSubmitSnipeRequest(betterproto.Message):
    entries: List["PostSubmitRequestEntry"] = betterproto.message_field(1)
    use_staked_rp_cs: Optional[bool] = betterproto.bool_field(2, optional=True)


@dataclass(eq=False, repr=False)
class PostSubmitSnipeResponse(betterproto.Message):
    transactions: List["PostSubmitBatchResponseEntry"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class PostSubmitResponse(betterproto.Message):
    signature: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetOpenOrdersRequest(betterproto.Message):
    market: str = betterproto.string_field(1)
    limit: int = betterproto.uint32_field(2)
    address: str = betterproto.string_field(3)
    open_orders_address: str = betterproto.string_field(4)
    project: "Project" = betterproto.enum_field(5)


@dataclass(eq=False, repr=False)
class GetOpenOrdersResponse(betterproto.Message):
    orders: List["Order"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetOrderByIdRequest(betterproto.Message):
    order_id: str = betterproto.string_field(1)
    market: str = betterproto.string_field(2)
    project: "Project" = betterproto.enum_field(3)


@dataclass(eq=False, repr=False)
class GetOrderByIdResponse(betterproto.Message):
    order: "Order" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetUnsettledRequest(betterproto.Message):
    market: str = betterproto.string_field(1)
    owner_address: str = betterproto.string_field(2)
    project: "Project" = betterproto.enum_field(3)


@dataclass(eq=False, repr=False)
class UnsettledAccountToken(betterproto.Message):
    address: str = betterproto.string_field(1)
    amount: float = betterproto.double_field(2)


@dataclass(eq=False, repr=False)
class UnsettledAccount(betterproto.Message):
    account: str = betterproto.string_field(1)
    base_token: "UnsettledAccountToken" = betterproto.message_field(2)
    quote_token: "UnsettledAccountToken" = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetUnsettledResponse(betterproto.Message):
    market: str = betterproto.string_field(1)
    unsettled: List["UnsettledAccount"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class GetOrderbooksStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    orderbook: "GetOrderbookResponse" = betterproto.message_field(2)
    timestamp: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetMarketDepthsStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    data: "GetMarketDepthResponse" = betterproto.message_field(2)
    timestamp: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetTickersStreamRequest(betterproto.Message):
    markets: List[str] = betterproto.string_field(1)
    project: "Project" = betterproto.enum_field(2)


@dataclass(eq=False, repr=False)
class GetTickersStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    ticker: "GetTickersResponse" = betterproto.message_field(2)
    timestamp: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetTradesStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    trades: "GetTradesResponse" = betterproto.message_field(2)
    timestamp: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetQuotesRequest(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    out_token: str = betterproto.string_field(2)
    in_amount: float = betterproto.double_field(3)
    slippage: float = betterproto.double_field(4)
    limit: int = betterproto.int32_field(5)
    projects: List["Project"] = betterproto.enum_field(6)


@dataclass(eq=False, repr=False)
class GetQuotesResponse(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    in_token_address: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    out_token_address: str = betterproto.string_field(4)
    in_amount: float = betterproto.double_field(5)
    quotes: List["ProjectQuote"] = betterproto.message_field(6)


@dataclass(eq=False, repr=False)
class GetRaydiumQuotesRequest(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    out_token: str = betterproto.string_field(2)
    in_amount: float = betterproto.double_field(3)
    slippage: float = betterproto.double_field(4)


@dataclass(eq=False, repr=False)
class GetRaydiumQuotesResponse(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    in_token_address: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    out_token_address: str = betterproto.string_field(4)
    in_amount: float = betterproto.double_field(5)
    routes: List["RaydiumQuoteRoute"] = betterproto.message_field(6)


@dataclass(eq=False, repr=False)
class GetPumpFunQuotesRequest(betterproto.Message):
    quote_type: str = betterproto.string_field(1)
    mint_address: str = betterproto.string_field(2)
    bonding_curve_address: str = betterproto.string_field(3)
    amount: float = betterproto.double_field(4)


@dataclass(eq=False, repr=False)
class GetPumpFunQuotesResponse(betterproto.Message):
    quote_type: str = betterproto.string_field(1)
    in_token_address: str = betterproto.string_field(2)
    in_amount: float = betterproto.double_field(3)
    out_token_address: str = betterproto.string_field(4)
    out_amount: float = betterproto.double_field(5)


@dataclass(eq=False, repr=False)
class GetRaydiumCpmmQuotesRequest(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    out_token: str = betterproto.string_field(2)
    in_amount: float = betterproto.double_field(3)
    slippage: float = betterproto.double_field(4)


@dataclass(eq=False, repr=False)
class GetRaydiumCpmmQuotesResponse(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    in_token_address: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    out_token_address: str = betterproto.string_field(4)
    in_amount: float = betterproto.double_field(5)
    trade_fee_rate: int = betterproto.uint64_field(6)
    routes: List["RaydiumQuoteRoute"] = betterproto.message_field(7)


@dataclass(eq=False, repr=False)
class PostRaydiumCpmmSwapRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    in_token: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    in_amount: float = betterproto.double_field(4)
    slippage: float = betterproto.double_field(5)
    pool_address: str = betterproto.string_field(6)
    compute_limit: int = betterproto.uint32_field(7)
    compute_price: int = betterproto.uint64_field(8)
    tip: Optional[int] = betterproto.uint64_field(9, optional=True)


@dataclass(eq=False, repr=False)
class PostRaydiumCpmmSwapResponse(betterproto.Message):
    transaction: "TransactionMessage" = betterproto.message_field(1)
    out_amount: float = betterproto.double_field(2)
    out_amount_min: float = betterproto.double_field(3)


@dataclass(eq=False, repr=False)
class GetJupiterQuotesRequest(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    out_token: str = betterproto.string_field(2)
    in_amount: float = betterproto.double_field(3)
    slippage: float = betterproto.double_field(4)


@dataclass(eq=False, repr=False)
class GetJupiterQuotesResponse(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    in_token_address: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    out_token_address: str = betterproto.string_field(4)
    in_amount: float = betterproto.double_field(5)
    routes: List["JupiterQuoteRoute"] = betterproto.message_field(6)


@dataclass(eq=False, repr=False)
class ProjectQuote(betterproto.Message):
    project: "Project" = betterproto.enum_field(1)
    routes: List["QuoteRoute"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class TradeSwapRequest(betterproto.Message):
    project: "Project" = betterproto.enum_field(1)
    owner_address: str = betterproto.string_field(2)
    in_token: str = betterproto.string_field(3)
    out_token: str = betterproto.string_field(4)
    in_amount: float = betterproto.double_field(5)
    slippage: float = betterproto.double_field(6)
    compute_limit: int = betterproto.uint32_field(7)
    compute_price: int = betterproto.uint64_field(8)
    tip: Optional[int] = betterproto.uint64_field(9, optional=True)


@dataclass(eq=False, repr=False)
class PostJupiterSwapRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    in_token: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    in_amount: float = betterproto.double_field(4)
    slippage: float = betterproto.double_field(5)
    compute_limit: int = betterproto.uint32_field(6)
    compute_price: int = betterproto.uint64_field(7)
    tip: Optional[int] = betterproto.uint64_field(8, optional=True)


@dataclass(eq=False, repr=False)
class PostJupiterSwapInstructionsRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    in_token: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    in_amount: float = betterproto.double_field(4)
    slippage: float = betterproto.double_field(5)
    compute_price: int = betterproto.uint64_field(7)
    tip: Optional[int] = betterproto.uint64_field(8, optional=True)


@dataclass(eq=False, repr=False)
class PostRaydiumSwapInstructionsRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    in_token: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    in_amount: float = betterproto.double_field(4)
    slippage: float = betterproto.double_field(5)
    compute_limit: int = betterproto.uint32_field(6)
    compute_price: int = betterproto.uint64_field(7)
    tip: Optional[int] = betterproto.uint64_field(8, optional=True)


@dataclass(eq=False, repr=False)
class PublicKeys(betterproto.Message):
    pks: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class PostJupiterSwapInstructionsResponse(betterproto.Message):
    instructions: List["InstructionJupiter"] = betterproto.message_field(1)
    address_lookup_table_addresses: Dict[str, "PublicKeys"] = betterproto.map_field(
        2, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE
    )
    out_amount: float = betterproto.double_field(3)
    out_amount_min: float = betterproto.double_field(4)
    price_impact: "_common__.PriceImpactPercentV2" = betterproto.message_field(5)
    fees: List["_common__.Fee"] = betterproto.message_field(6)


@dataclass(eq=False, repr=False)
class PostRaydiumSwapInstructionsResponse(betterproto.Message):
    instructions: List["InstructionRaydium"] = betterproto.message_field(1)
    out_amount: float = betterproto.double_field(2)
    out_amount_min: float = betterproto.double_field(3)
    price_impact: "_common__.PriceImpactPercentV2" = betterproto.message_field(4)
    fees: List["_common__.Fee"] = betterproto.message_field(5)


@dataclass(eq=False, repr=False)
class PostRaydiumSwapRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    in_token: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    in_amount: float = betterproto.double_field(4)
    slippage: float = betterproto.double_field(5)
    compute_limit: int = betterproto.uint32_field(6)
    compute_price: int = betterproto.uint64_field(7)
    tip: Optional[int] = betterproto.uint64_field(8, optional=True)


@dataclass(eq=False, repr=False)
class PostRaydiumSwapResponse(betterproto.Message):
    transactions: List["TransactionMessage"] = betterproto.message_field(1)
    out_amount: float = betterproto.double_field(2)
    out_amount_min: float = betterproto.double_field(3)
    price_impact: "_common__.PriceImpactPercentV2" = betterproto.message_field(4)
    fees: List["_common__.Fee"] = betterproto.message_field(5)


@dataclass(eq=False, repr=False)
class GetRaydiumClmmPoolsRequest(betterproto.Message):
    pair_or_address: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetRaydiumClmmPoolsResponse(betterproto.Message):
    pools: List["ProjectPool"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class PostJupiterSwapResponse(betterproto.Message):
    transactions: List["TransactionMessage"] = betterproto.message_field(1)
    out_amount: float = betterproto.double_field(2)
    out_amount_min: float = betterproto.double_field(3)
    price_impact: "_common__.PriceImpactPercentV2" = betterproto.message_field(4)
    fees: List["_common__.Fee"] = betterproto.message_field(5)


@dataclass(eq=False, repr=False)
class PostRaydiumRouteSwapResponse(betterproto.Message):
    transactions: List["TransactionMessage"] = betterproto.message_field(1)
    out_amount: float = betterproto.double_field(2)
    out_amount_min: float = betterproto.double_field(3)


@dataclass(eq=False, repr=False)
class PostJupiterRouteSwapResponse(betterproto.Message):
    transactions: List["TransactionMessage"] = betterproto.message_field(1)
    out_amount: float = betterproto.double_field(2)
    out_amount_min: float = betterproto.double_field(3)
    price_impact: "_common__.PriceImpactPercentV2" = betterproto.message_field(4)
    fees: List["_common__.Fee"] = betterproto.message_field(5)


@dataclass(eq=False, repr=False)
class RouteTradeSwapRequest(betterproto.Message):
    project: "Project" = betterproto.enum_field(1)
    owner_address: str = betterproto.string_field(2)
    steps: List["RouteStep"] = betterproto.message_field(3)
    slippage: float = betterproto.double_field(4)
    compute_limit: int = betterproto.uint32_field(5)
    compute_price: int = betterproto.uint64_field(6)
    tip: Optional[int] = betterproto.uint64_field(7, optional=True)


@dataclass(eq=False, repr=False)
class PostRaydiumRouteSwapRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    steps: List["RaydiumRouteStep"] = betterproto.message_field(2)
    slippage: float = betterproto.double_field(3)
    compute_limit: int = betterproto.uint32_field(4)
    compute_price: int = betterproto.uint64_field(5)
    tip: Optional[int] = betterproto.uint64_field(6, optional=True)


@dataclass(eq=False, repr=False)
class RaydiumRouteStep(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    in_amount: float = betterproto.double_field(2)
    out_token: str = betterproto.string_field(3)
    out_amount: float = betterproto.double_field(4)
    out_amount_min: float = betterproto.double_field(5)
    pool_address: str = betterproto.string_field(6)
    project: "StepProject" = betterproto.message_field(7)


@dataclass(eq=False, repr=False)
class GetRaydiumClmmQuotesRequest(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    out_token: str = betterproto.string_field(2)
    in_amount: float = betterproto.double_field(3)
    slippage: float = betterproto.double_field(4)


@dataclass(eq=False, repr=False)
class GetRaydiumClmmQuotesResponse(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    in_token_address: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    out_token_address: str = betterproto.string_field(4)
    in_amount: float = betterproto.double_field(5)
    routes: List["RaydiumQuoteRoute"] = betterproto.message_field(6)


@dataclass(eq=False, repr=False)
class PostJupiterRouteSwapRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    steps: List["JupiterRouteStep"] = betterproto.message_field(2)
    slippage: float = betterproto.double_field(3)
    compute_limit: int = betterproto.uint32_field(4)
    compute_price: int = betterproto.uint64_field(5)
    tip: Optional[int] = betterproto.uint64_field(6, optional=True)


@dataclass(eq=False, repr=False)
class JupiterRouteStep(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    in_amount: float = betterproto.double_field(2)
    out_token: str = betterproto.string_field(3)
    out_amount: float = betterproto.double_field(4)
    out_amount_min: float = betterproto.double_field(5)
    project: "StepProject" = betterproto.message_field(6)
    fee: "_common__.Fee" = betterproto.message_field(7)


@dataclass(eq=False, repr=False)
class RouteStep(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    in_amount: float = betterproto.double_field(2)
    out_token: str = betterproto.string_field(3)
    out_amount: float = betterproto.double_field(4)
    out_amount_min: float = betterproto.double_field(5)
    project: "StepProject" = betterproto.message_field(6)
    fee: "_common__.Fee" = betterproto.message_field(7)


@dataclass(eq=False, repr=False)
class TradeSwapResponse(betterproto.Message):
    project: "Project" = betterproto.enum_field(1)
    transactions: List["TransactionMessage"] = betterproto.message_field(2)
    out_amount: float = betterproto.double_field(3)
    out_amount_min: float = betterproto.double_field(4)
    price_impact: "_common__.PriceImpactPercent" = betterproto.message_field(5)
    fees: List["_common__.Fee"] = betterproto.message_field(6)


@dataclass(eq=False, repr=False)
class QuoteRoute(betterproto.Message):
    in_amount: float = betterproto.double_field(1)
    out_amount: float = betterproto.double_field(2)
    out_amount_min: float = betterproto.double_field(3)
    steps: List["QuoteStep"] = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class QuoteStep(betterproto.Message):
    project: "StepProject" = betterproto.message_field(1)
    in_token: str = betterproto.string_field(2)
    in_token_address: str = betterproto.string_field(3)
    out_token: str = betterproto.string_field(4)
    out_token_address: str = betterproto.string_field(5)
    in_amount: float = betterproto.double_field(6)
    out_amount: float = betterproto.double_field(7)
    slippage: float = betterproto.double_field(8)
    price_impact_percent: "_common__.PriceImpactPercent" = betterproto.message_field(9)
    fee: "_common__.Fee" = betterproto.message_field(10)
    out_amount_min: float = betterproto.double_field(11)


@dataclass(eq=False, repr=False)
class JupiterQuoteRoute(betterproto.Message):
    in_amount: float = betterproto.double_field(1)
    out_amount: float = betterproto.double_field(2)
    out_amount_min: float = betterproto.double_field(3)
    steps: List["JupiterQuoteStep"] = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class JupiterQuoteStep(betterproto.Message):
    project: "StepProject" = betterproto.message_field(1)
    in_token: str = betterproto.string_field(2)
    in_token_address: str = betterproto.string_field(3)
    out_token: str = betterproto.string_field(4)
    out_token_address: str = betterproto.string_field(5)
    in_amount: float = betterproto.double_field(6)
    out_amount: float = betterproto.double_field(7)
    slippage: float = betterproto.double_field(8)
    price_impact_percent: "_common__.PriceImpactPercentV2" = betterproto.message_field(
        9
    )
    fee: "_common__.Fee" = betterproto.message_field(10)
    out_amount_min: float = betterproto.double_field(11)


@dataclass(eq=False, repr=False)
class RaydiumQuoteRoute(betterproto.Message):
    in_amount: float = betterproto.double_field(1)
    out_amount: float = betterproto.double_field(2)
    out_amount_min: float = betterproto.double_field(3)
    steps: List["RaydiumQuoteStep"] = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class RaydiumQuoteStep(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    in_token_address: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    out_token_address: str = betterproto.string_field(4)
    in_amount: float = betterproto.double_field(5)
    out_amount: float = betterproto.double_field(6)
    slippage: float = betterproto.double_field(7)
    price_impact_percent: "_common__.PriceImpactPercentV2" = betterproto.message_field(
        8
    )
    fee: "_common__.Fee" = betterproto.message_field(9)
    out_amount_min: float = betterproto.double_field(10)
    project: "StepProject" = betterproto.message_field(11)


@dataclass(eq=False, repr=False)
class StepProject(betterproto.Message):
    label: str = betterproto.string_field(1)
    id: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class GetRecentBlockHashRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetRecentBlockHashResponse(betterproto.Message):
    block_hash: str = betterproto.string_field(1)
    timestamp: datetime = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class GetRecentBlockHashRequestV2(betterproto.Message):
    offset: int = betterproto.uint64_field(1)


@dataclass(eq=False, repr=False)
class GetRecentBlockHashResponseV2(betterproto.Message):
    block_hash: str = betterproto.string_field(1)
    timestamp: datetime = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class Block(betterproto.Message):
    slot: int = betterproto.uint64_field(1)
    hash: str = betterproto.string_field(2)
    time: int = betterproto.int64_field(3)
    height: int = betterproto.uint64_field(4)


@dataclass(eq=False, repr=False)
class GetBlockStreamRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetBlockStreamResponse(betterproto.Message):
    block: "Block" = betterproto.message_field(1)
    timestamp: datetime = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class InstructionRequest(betterproto.Message):
    program_id_index: int = betterproto.uint32_field(1)


@dataclass(eq=False, repr=False)
class GetPoolsRequest(betterproto.Message):
    projects: List["Project"] = betterproto.enum_field(1)
    pair_or_address: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class GetPoolsResponse(betterproto.Message):
    projects: List["ProjectPools"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetRaydiumPoolsRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetRaydiumPoolsResponse(betterproto.Message):
    pools: List["ProjectPool"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetRaydiumPoolReserveRequest(betterproto.Message):
    pairs_or_addresses: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetRaydiumPoolReserveResponse(betterproto.Message):
    pools: List["ProjectPool"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetRateLimitRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetRateLimitResponse(betterproto.Message):
    account_id: str = betterproto.string_field(1)
    tier: str = betterproto.string_field(2)
    interval: str = betterproto.string_field(3)
    interval_num: int = betterproto.uint64_field(4)
    limit: int = betterproto.uint64_field(5)
    count: int = betterproto.uint64_field(6)
    reset: int = betterproto.uint64_field(7)
    stream_infos: List["StreamInfo"] = betterproto.message_field(8)


@dataclass(eq=False, repr=False)
class StreamInfo(betterproto.Message):
    stream_name: str = betterproto.string_field(1)
    subscription_id: str = betterproto.string_field(2)
    start_time: int = betterproto.int64_field(3)
    credit_used: int = betterproto.int64_field(4)


@dataclass(eq=False, repr=False)
class GetTransactionRequest(betterproto.Message):
    signature: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetTransactionResponse(betterproto.Message):
    status: str = betterproto.string_field(1)
    metadata: "TransactionMeta" = betterproto.message_field(2)
    slot: int = betterproto.uint64_field(3)
    block_time: int = betterproto.uint64_field(4)
    version: int = betterproto.int32_field(5)


@dataclass(eq=False, repr=False)
class Instruction(betterproto.Message):
    program_id_index: int = betterproto.uint32_field(1)
    accounts: List[int] = betterproto.uint32_field(2)
    data: bytes = betterproto.bytes_field(3)


@dataclass(eq=False, repr=False)
class AccountMeta(betterproto.Message):
    program_id: str = betterproto.string_field(1)
    is_signer: bool = betterproto.bool_field(2)
    is_writable: bool = betterproto.bool_field(3)


@dataclass(eq=False, repr=False)
class InstructionRaydium(betterproto.Message):
    program_id: str = betterproto.string_field(1)
    accounts: List["AccountMeta"] = betterproto.message_field(2)
    data: bytes = betterproto.bytes_field(3)


@dataclass(eq=False, repr=False)
class InstructionJupiter(betterproto.Message):
    program_id: str = betterproto.string_field(1)
    accounts: List["AccountMeta"] = betterproto.message_field(2)
    data: bytes = betterproto.bytes_field(3)


@dataclass(eq=False, repr=False)
class TransactionMeta(betterproto.Message):
    err: str = betterproto.string_field(1)
    errored: bool = betterproto.bool_field(2)
    fee: int = betterproto.uint64_field(3)
    pre_balances: List[int] = betterproto.uint64_field(4)
    post_balances: List[int] = betterproto.uint64_field(5)
    inner_instructions: List["TransactionMetaInnerInstruction"] = (
        betterproto.message_field(6)
    )
    log_messages: List[str] = betterproto.string_field(7)
    pre_token_balances: List["TransactionMetaTokenBalance"] = betterproto.message_field(
        8
    )
    post_token_balances: List["TransactionMetaTokenBalance"] = (
        betterproto.message_field(9)
    )


@dataclass(eq=False, repr=False)
class TransactionMetaInnerInstruction(betterproto.Message):
    index: int = betterproto.uint32_field(1)
    instructions: List["Instruction"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class TransactionMetaTokenBalance(betterproto.Message):
    account_index: int = betterproto.uint32_field(1)
    mint: str = betterproto.string_field(2)
    ui_token_amount: "UiTokenAmount" = betterproto.message_field(3)
    owner: str = betterproto.string_field(4)


@dataclass(eq=False, repr=False)
class UiTokenAmount(betterproto.Message):
    ui_amount: float = betterproto.double_field(1)
    decimals: int = betterproto.uint32_field(2)
    amount: str = betterproto.string_field(3)
    ui_amount_string: str = betterproto.string_field(4)


@dataclass(eq=False, repr=False)
class ProjectPools(betterproto.Message):
    project: "Project" = betterproto.enum_field(1)
    pools: List["ProjectPool"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class ProjectPool(betterproto.Message):
    pool: str = betterproto.string_field(1)
    pool_address: str = betterproto.string_field(2)
    token1_reserves: int = betterproto.int64_field(3)
    token1_mint_address: str = betterproto.string_field(4)
    token1_mint_symbol: str = betterproto.string_field(5)
    token2_reserves: int = betterproto.int64_field(6)
    token2_mint_address: str = betterproto.string_field(7)
    token2_mint_symbol: str = betterproto.string_field(8)
    open_time: int = betterproto.uint64_field(9)
    pool_type: str = betterproto.string_field(10)
    liquidity_pool_keys: "LiquidityPoolKeys" = betterproto.message_field(11)


@dataclass(eq=False, repr=False)
class LiquidityPoolKeys(betterproto.Message):
    id: str = betterproto.string_field(1)
    base_mint: str = betterproto.string_field(2)
    quote_mint: str = betterproto.string_field(3)
    lp_mint: str = betterproto.string_field(4)
    version: int = betterproto.uint32_field(5)
    program_id: str = betterproto.string_field(6)
    authority: str = betterproto.string_field(7)
    base_vault: str = betterproto.string_field(8)
    quote_vault: str = betterproto.string_field(9)
    lp_vault: str = betterproto.string_field(10)
    open_orders: str = betterproto.string_field(11)
    target_orders: str = betterproto.string_field(12)
    withdraw_queue: str = betterproto.string_field(13)
    market_version: int = betterproto.uint32_field(14)
    market_program_id: str = betterproto.string_field(15)
    market_id: str = betterproto.string_field(16)
    market_authority: str = betterproto.string_field(17)
    market_base_vault: str = betterproto.string_field(18)
    market_quote_vault: str = betterproto.string_field(19)
    market_bids: str = betterproto.string_field(20)
    market_asks: str = betterproto.string_field(21)
    market_event_queue: str = betterproto.string_field(22)
    trade_fee_rate: int = betterproto.uint64_field(23)


@dataclass(eq=False, repr=False)
class GetQuotesStreamRequest(betterproto.Message):
    projects: List["Project"] = betterproto.enum_field(1)
    token_pairs: List["TokenPair"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class GetQuotesStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    quote: "GetQuotesStreamUpdate" = betterproto.message_field(2)
    timestamp: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetQuotesStreamUpdate(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    in_token_address: str = betterproto.string_field(2)
    out_token: str = betterproto.string_field(3)
    out_token_address: str = betterproto.string_field(4)
    in_amount: float = betterproto.double_field(5)
    out_amount: float = betterproto.double_field(6)
    project: "Project" = betterproto.enum_field(7)


@dataclass(eq=False, repr=False)
class GetSwapsStreamRequest(betterproto.Message):
    projects: List["Project"] = betterproto.enum_field(1)
    pools: List[str] = betterproto.string_field(2)
    include_failed: bool = betterproto.bool_field(3)


@dataclass(eq=False, repr=False)
class GetSwapsStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    swap: "GetSwapsStreamUpdate" = betterproto.message_field(2)
    timestamp: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetNewRaydiumPoolsRequest(betterproto.Message):
    include_cpmm: Optional[bool] = betterproto.bool_field(1, optional=True)


@dataclass(eq=False, repr=False)
class GetNewRaydiumPoolsByTransactionRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetNewRaydiumPoolsByTransactionResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    signature: str = betterproto.string_field(2)
    pool_creator_wallet: str = betterproto.string_field(3)
    pool: "ProjectPool" = betterproto.message_field(4)
    timestamp: datetime = betterproto.message_field(5)


@dataclass(eq=False, repr=False)
class GetNewRaydiumPoolsResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    pool: "ProjectPool" = betterproto.message_field(2)
    timestamp: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetSwapsStreamUpdate(betterproto.Message):
    success: bool = betterproto.bool_field(1)
    project: "Project" = betterproto.enum_field(2)
    pool_address: str = betterproto.string_field(3)
    in_token: str = betterproto.string_field(4)
    in_token_address: str = betterproto.string_field(5)
    out_token: str = betterproto.string_field(6)
    out_token_address: str = betterproto.string_field(7)
    in_amount: float = betterproto.double_field(8)
    out_amount_min: float = betterproto.double_field(9)
    source_account: str = betterproto.string_field(10)
    destination_account: str = betterproto.string_field(11)
    owner_account: str = betterproto.string_field(12)
    signature: str = betterproto.string_field(13)


@dataclass(eq=False, repr=False)
class TokenPair(betterproto.Message):
    in_token: str = betterproto.string_field(1)
    out_token: str = betterproto.string_field(2)
    in_amount: float = betterproto.double_field(3)


@dataclass(eq=False, repr=False)
class GetPriceRequest(betterproto.Message):
    tokens: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetPriceResponse(betterproto.Message):
    token_prices: List["TokenPrice"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetRaydiumPricesRequest(betterproto.Message):
    tokens: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetJupiterPricesRequest(betterproto.Message):
    tokens: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetRaydiumPricesResponse(betterproto.Message):
    token_prices: List["TokenPriceV2"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetJupiterPricesResponse(betterproto.Message):
    token_prices: List["TokenPriceV2"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetZetaTransactionStreamRequest(betterproto.Message):
    instructions: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class TransactionZeta(betterproto.Message):
    signatures: List[str] = betterproto.string_field(1)
    message: "TransactionMessageZeta" = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class TransactionMessageZeta(betterproto.Message):
    header: "TransactionMessageHeader" = betterproto.message_field(2)
    account_keys: List[str] = betterproto.string_field(3)
    recent_blockhash: str = betterproto.string_field(4)
    instructions: List["Instruction"] = betterproto.message_field(5)


@dataclass(eq=False, repr=False)
class TransactionMessageHeader(betterproto.Message):
    num_required_signatures: int = betterproto.uint32_field(1)
    num_readonly_signed_accounts: int = betterproto.uint32_field(2)
    num_readonly_unsigned_accounts: int = betterproto.uint32_field(3)


@dataclass(eq=False, repr=False)
class GetZetaTransactionStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    transaction: "TransactionZeta" = betterproto.message_field(2)
    meta: "TransactionMeta" = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class TokenPrice(betterproto.Message):
    token: str = betterproto.string_field(1)
    token_address: str = betterproto.string_field(2)
    project: "Project" = betterproto.enum_field(3)
    buy: float = betterproto.double_field(4)
    buy_size: float = betterproto.double_field(5)
    sell: float = betterproto.double_field(6)
    sell_size: float = betterproto.double_field(7)


@dataclass(eq=False, repr=False)
class TokenPriceV2(betterproto.Message):
    token: str = betterproto.string_field(1)
    token_address: str = betterproto.string_field(2)
    buy: float = betterproto.double_field(3)
    buy_size: float = betterproto.double_field(4)
    sell: float = betterproto.double_field(5)
    sell_size: float = betterproto.double_field(6)


@dataclass(eq=False, repr=False)
class GetPoolReservesStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    reserves: "PoolReserves" = betterproto.message_field(2)
    timestamp: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class PoolReserves(betterproto.Message):
    token1_reserves: str = betterproto.string_field(1)
    token1_address: str = betterproto.string_field(2)
    token2_reserves: str = betterproto.string_field(3)
    token2_address: str = betterproto.string_field(4)
    pool_address: str = betterproto.string_field(5)
    project: "Project" = betterproto.enum_field(6)


@dataclass(eq=False, repr=False)
class GetPoolReservesStreamRequest(betterproto.Message):
    projects: List["Project"] = betterproto.enum_field(1)
    pools: List[str] = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class GetPricesStreamRequest(betterproto.Message):
    projects: List["Project"] = betterproto.enum_field(1)
    tokens: List[str] = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class GetPricesStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    price: "TokenPrice" = betterproto.message_field(2)
    timestamp: datetime = betterproto.message_field(3)


@dataclass(eq=False, repr=False)
class GetPriorityFeeRequest(betterproto.Message):
    project: "Project" = betterproto.enum_field(1)
    percentile: Optional[float] = betterproto.double_field(2, optional=True)


@dataclass(eq=False, repr=False)
class GetPriorityFeeResponse(betterproto.Message):
    project: "Project" = betterproto.enum_field(1)
    percentile: float = betterproto.double_field(2)
    fee_at_percentile: int = betterproto.uint64_field(3)


@dataclass(eq=False, repr=False)
class GetPriorityFeeByProgramRequest(betterproto.Message):
    programs: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetPriorityFeeByProgramResponse(betterproto.Message):
    data: List["ProgramPriorityFee"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class ProgramPriorityFee(betterproto.Message):
    ten: int = betterproto.uint64_field(1)
    hundred: int = betterproto.uint64_field(2)
    fifteen: int = betterproto.uint64_field(3)
    twenty: int = betterproto.uint64_field(4)
    twenty_five: int = betterproto.uint64_field(5)
    thirty: int = betterproto.uint64_field(6)
    thirty_five: int = betterproto.uint64_field(7)
    forty: int = betterproto.uint64_field(8)
    forty_five: int = betterproto.uint64_field(9)
    five: int = betterproto.uint64_field(10)
    fifty: int = betterproto.uint64_field(11)
    fifty_five: int = betterproto.uint64_field(12)
    sixty: int = betterproto.uint64_field(13)
    sixty_five: int = betterproto.uint64_field(14)
    seventy: int = betterproto.uint64_field(15)
    seventy_five: int = betterproto.uint64_field(16)
    eighty: int = betterproto.uint64_field(17)
    eighty_five: int = betterproto.uint64_field(18)
    ninety: int = betterproto.uint64_field(19)
    ninety_five: int = betterproto.uint64_field(20)
    program: str = betterproto.string_field(21)


@dataclass(eq=False, repr=False)
class GetBundleTipRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetBundleTipResponse(betterproto.Message):
    timestamp: datetime = betterproto.message_field(1)
    percentile25: float = betterproto.double_field(2)
    percentile50: float = betterproto.double_field(3)
    percentile75: float = betterproto.double_field(4)
    percentile95: float = betterproto.double_field(5)
    percentile99: float = betterproto.double_field(6)
    ema_percentile50: float = betterproto.double_field(7)


@dataclass(eq=False, repr=False)
class GetMarketsRequestV2(betterproto.Message):
    """Openbook V2 Messages"""

    pass


@dataclass(eq=False, repr=False)
class GetMarketsResponseV2(betterproto.Message):
    markets: Dict[str, "MarketV2"] = betterproto.map_field(
        1, betterproto.TYPE_STRING, betterproto.TYPE_MESSAGE
    )


@dataclass(eq=False, repr=False)
class MarketV2(betterproto.Message):
    market: str = betterproto.string_field(1)
    address: str = betterproto.string_field(3)
    base_mint: str = betterproto.string_field(4)
    quoted_mint: str = betterproto.string_field(5)
    base_decimals: int = betterproto.int64_field(6)
    quote_decimals: int = betterproto.int64_field(7)


@dataclass(eq=False, repr=False)
class GetTickersRequestV2(betterproto.Message):
    market: str = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetTickersResponseV2(betterproto.Message):
    tickers: List["TickerV2"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class TickerV2(betterproto.Message):
    market: str = betterproto.string_field(1)
    market_address: str = betterproto.string_field(2)
    bid: float = betterproto.double_field(3)
    bid_size: float = betterproto.double_field(4)
    ask: float = betterproto.double_field(5)
    ask_size: float = betterproto.double_field(6)


@dataclass(eq=False, repr=False)
class GetOrderbookRequestV2(betterproto.Message):
    market: str = betterproto.string_field(1)
    limit: int = betterproto.uint32_field(2)


@dataclass(eq=False, repr=False)
class GetOrderbookResponseV2(betterproto.Message):
    market: str = betterproto.string_field(1)
    market_address: str = betterproto.string_field(2)
    bids: List["OrderbookItemV2"] = betterproto.message_field(3)
    asks: List["OrderbookItemV2"] = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class OrderbookItemV2(betterproto.Message):
    price: float = betterproto.double_field(1)
    size: float = betterproto.double_field(2)
    order_id: str = betterproto.string_field(3)
    client_order_id: int = betterproto.uint64_field(4)
    owner_address: str = betterproto.string_field(5)


@dataclass(eq=False, repr=False)
class GetMarketDepthRequestV2(betterproto.Message):
    market: str = betterproto.string_field(1)
    limit: int = betterproto.uint32_field(2)


@dataclass(eq=False, repr=False)
class GetMarketDepthResponseV2(betterproto.Message):
    market: str = betterproto.string_field(1)
    market_address: str = betterproto.string_field(2)
    bids: List["MarketDepthItemV2"] = betterproto.message_field(3)
    asks: List["MarketDepthItemV2"] = betterproto.message_field(4)


@dataclass(eq=False, repr=False)
class MarketDepthItemV2(betterproto.Message):
    price: float = betterproto.double_field(1)
    size: float = betterproto.double_field(2)


@dataclass(eq=False, repr=False)
class PostOrderRequestV2(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    payer_address: str = betterproto.string_field(2)
    market: str = betterproto.string_field(3)
    side: str = betterproto.string_field(4)
    type: str = betterproto.string_field(5)
    amount: float = betterproto.double_field(6)
    price: float = betterproto.double_field(7)
    open_orders_address: str = betterproto.string_field(8)
    client_order_id: int = betterproto.uint64_field(9)
    compute_limit: int = betterproto.uint32_field(10)
    compute_price: int = betterproto.uint64_field(11)
    tip: Optional[int] = betterproto.uint64_field(12, optional=True)


@dataclass(eq=False, repr=False)
class PostReplaceOrderRequestV2(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    payer_address: str = betterproto.string_field(2)
    market: str = betterproto.string_field(3)
    side: str = betterproto.string_field(4)
    type: str = betterproto.string_field(5)
    amount: float = betterproto.double_field(6)
    price: float = betterproto.double_field(7)
    open_orders_address: str = betterproto.string_field(8)
    client_order_id: int = betterproto.uint64_field(9)
    order_id: str = betterproto.string_field(10)
    compute_limit: int = betterproto.uint32_field(11)
    compute_price: int = betterproto.uint64_field(12)
    tip: Optional[int] = betterproto.uint64_field(13, optional=True)


@dataclass(eq=False, repr=False)
class PostCancelOrderRequestV2(betterproto.Message):
    order_id: str = betterproto.string_field(1)
    side: str = betterproto.string_field(2)
    market_address: str = betterproto.string_field(3)
    owner_address: str = betterproto.string_field(4)
    open_orders_address: str = betterproto.string_field(5)
    client_order_id: int = betterproto.uint64_field(6)
    compute_limit: int = betterproto.uint32_field(7)
    compute_price: int = betterproto.uint64_field(8)
    tip: Optional[int] = betterproto.uint64_field(9, optional=True)


@dataclass(eq=False, repr=False)
class PostCancelOrderResponseV2(betterproto.Message):
    transactions: List["TransactionMessage"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class PostSettleRequestV2(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    market: str = betterproto.string_field(2)
    base_token_wallet: str = betterproto.string_field(3)
    quote_token_wallet: str = betterproto.string_field(4)
    open_orders_address: str = betterproto.string_field(5)
    compute_limit: int = betterproto.uint32_field(6)
    compute_price: int = betterproto.uint64_field(7)
    tip: Optional[int] = betterproto.uint64_field(8, optional=True)


@dataclass(eq=False, repr=False)
class PostZetaCrossMarginAccountRequest(betterproto.Message):
    owner_address: str = betterproto.string_field(1)
    compute_limit: int = betterproto.uint32_field(2)
    compute_price: int = betterproto.uint64_field(3)
    tip: Optional[int] = betterproto.uint64_field(4, optional=True)


@dataclass(eq=False, repr=False)
class PostZetaCrossMarginAccountResponse(betterproto.Message):
    transaction: "TransactionMessage" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetOpenOrdersRequestV2(betterproto.Message):
    market: str = betterproto.string_field(1)
    limit: int = betterproto.uint32_field(2)
    address: str = betterproto.string_field(3)
    open_orders_address: str = betterproto.string_field(4)
    order_id: str = betterproto.string_field(5)
    client_order_id: int = betterproto.uint64_field(6)


@dataclass(eq=False, repr=False)
class GetUnsettledRequestV2(betterproto.Message):
    market: str = betterproto.string_field(1)
    owner_address: str = betterproto.string_field(2)


@dataclass(eq=False, repr=False)
class GetOpenOrdersResponseV2(betterproto.Message):
    orders: List["OrderV2"] = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class OrderV2(betterproto.Message):
    order_id: str = betterproto.string_field(1)
    market: str = betterproto.string_field(2)
    side: str = betterproto.string_field(3)
    type: str = betterproto.string_field(4)
    price: float = betterproto.double_field(5)
    remaining_size: float = betterproto.double_field(6)
    created_at: datetime = betterproto.message_field(7)
    client_order_id: str = betterproto.string_field(8)
    open_order_account: str = betterproto.string_field(9)


@dataclass(eq=False, repr=False)
class GetPumpFunSwapsStreamRequest(betterproto.Message):
    tokens: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetPumpFunSwapsStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    txn_hash: str = betterproto.string_field(2)
    mint_address: str = betterproto.string_field(3)
    user_address: str = betterproto.string_field(4)
    user_token_account_address: str = betterproto.string_field(5)
    bonding_curve_address: str = betterproto.string_field(6)
    token_vault_address: str = betterproto.string_field(7)
    sol_amount: int = betterproto.uint64_field(8)
    token_amount: int = betterproto.uint64_field(9)
    is_buy: bool = betterproto.bool_field(10)
    virtual_sol_reserves: int = betterproto.uint64_field(11)
    virtual_token_reserves: int = betterproto.uint64_field(12)
    timestamp: datetime = betterproto.message_field(13)


@dataclass(eq=False, repr=False)
class GetPumpFunNewTokensStreamRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetPumpFunNewTokensStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    txn_hash: str = betterproto.string_field(2)
    name: str = betterproto.string_field(3)
    symbol: str = betterproto.string_field(4)
    uri: str = betterproto.string_field(5)
    mint: str = betterproto.string_field(6)
    bonding_curve: str = betterproto.string_field(7)
    creator: str = betterproto.string_field(8)
    timestamp: datetime = betterproto.message_field(9)


@dataclass(eq=False, repr=False)
class GetPumpFunNewAmmPoolStreamRequest(betterproto.Message):
    pass


@dataclass(eq=False, repr=False)
class GetPumpFunNewAmmPoolStreamResponse(betterproto.Message):
    slot: int = betterproto.int64_field(1)
    creator: str = betterproto.string_field(2)
    pool: str = betterproto.string_field(3)
    base_mint: str = betterproto.string_field(4)
    quote_mint: str = betterproto.string_field(5)
    lp_mint: str = betterproto.string_field(6)
    timestamp: datetime = betterproto.message_field(9)


@dataclass(eq=False, repr=False)
class GetPumpFunAmmSwapStreamRequest(betterproto.Message):
    pool: List[str] = betterproto.string_field(1)


@dataclass(eq=False, repr=False)
class GetPumpFunAmmSwapStreamResponse(betterproto.Message):
    pool: str = betterproto.string_field(1)
    user: str = betterproto.string_field(2)
    in_mint: str = betterproto.string_field(3)
    out_mint: str = betterproto.string_field(4)
    max_in_amount: float = betterproto.double_field(5)
    out_amount: float = betterproto.double_field(6)


@dataclass(eq=False, repr=False)
class PostPumpFunSwapRequest(betterproto.Message):
    user_address: str = betterproto.string_field(1)
    bonding_curve_address: str = betterproto.string_field(2)
    token_address: str = betterproto.string_field(3)
    token_amount: float = betterproto.double_field(4)
    sol_threshold: float = betterproto.double_field(5)
    is_buy: bool = betterproto.bool_field(6)
    slippage: float = betterproto.double_field(7)
    compute_limit: int = betterproto.uint32_field(8)
    compute_price: int = betterproto.uint64_field(9)
    tip: Optional[int] = betterproto.uint64_field(10, optional=True)


@dataclass(eq=False, repr=False)
class PostPumpFunSwapRequestSol(betterproto.Message):
    user_address: str = betterproto.string_field(1)
    bonding_curve_address: str = betterproto.string_field(2)
    token_address: str = betterproto.string_field(3)
    sol_amount: float = betterproto.double_field(4)
    slippage: float = betterproto.double_field(5)
    compute_limit: int = betterproto.uint32_field(6)
    compute_price: int = betterproto.uint64_field(7)
    tip: Optional[int] = betterproto.uint64_field(8, optional=True)


@dataclass(eq=False, repr=False)
class PostPumpFunSwapResponse(betterproto.Message):
    transaction: "TransactionMessageV2" = betterproto.message_field(1)


@dataclass(eq=False, repr=False)
class GetLeaderScheduleRequest(betterproto.Message):
    max_slots: int = betterproto.uint64_field(1)


@dataclass(eq=False, repr=False)
class GetLeaderScheduleResponse(betterproto.Message):
    current_slot: int = betterproto.uint64_field(1)
    leader_schedule: List["LeaderSchedule"] = betterproto.message_field(2)


@dataclass(eq=False, repr=False)
class LeaderSchedule(betterproto.Message):
    slot: int = betterproto.uint64_field(1)
    leader: str = betterproto.string_field(2)
    is_jito: bool = betterproto.bool_field(3)
    is_high_risk: bool = betterproto.bool_field(4)
    jito_region: str = betterproto.string_field(5)
    is_malicious: bool = betterproto.bool_field(6)


class ApiStub(betterproto.ServiceStub):
    async def get_rate_limit(
        self,
        get_rate_limit_request: "GetRateLimitRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetRateLimitResponse":
        return await self._unary_unary(
            "/api.Api/GetRateLimit",
            get_rate_limit_request,
            GetRateLimitResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_transaction(
        self,
        get_transaction_request: "GetTransactionRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetTransactionResponse":
        return await self._unary_unary(
            "/api.Api/GetTransaction",
            get_transaction_request,
            GetTransactionResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_submit_v2(
        self,
        post_submit_request: "PostSubmitRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostSubmitResponse":
        return await self._unary_unary(
            "/api.Api/PostSubmitV2",
            post_submit_request,
            PostSubmitResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_submit_batch_v2(
        self,
        post_submit_batch_request: "PostSubmitBatchRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostSubmitBatchResponse":
        return await self._unary_unary(
            "/api.Api/PostSubmitBatchV2",
            post_submit_batch_request,
            PostSubmitBatchResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_submit_snipe_v2(
        self,
        post_submit_snipe_request: "PostSubmitSnipeRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostSubmitSnipeResponse":
        return await self._unary_unary(
            "/api.Api/PostSubmitSnipeV2",
            post_submit_snipe_request,
            PostSubmitSnipeResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_submit_paladin_v2(
        self,
        post_submit_paladin_request: "PostSubmitPaladinRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostSubmitResponse":
        return await self._unary_unary(
            "/api.Api/PostSubmitPaladinV2",
            post_submit_paladin_request,
            PostSubmitResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_raydium_pools(
        self,
        get_raydium_pools_request: "GetRaydiumPoolsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetRaydiumPoolsResponse":
        return await self._unary_unary(
            "/api.Api/GetRaydiumPools",
            get_raydium_pools_request,
            GetRaydiumPoolsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_raydium_pool_reserve(
        self,
        get_raydium_pool_reserve_request: "GetRaydiumPoolReserveRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetRaydiumPoolReserveResponse":
        return await self._unary_unary(
            "/api.Api/GetRaydiumPoolReserve",
            get_raydium_pool_reserve_request,
            GetRaydiumPoolReserveResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_raydium_quotes(
        self,
        get_raydium_quotes_request: "GetRaydiumQuotesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetRaydiumQuotesResponse":
        return await self._unary_unary(
            "/api.Api/GetRaydiumQuotes",
            get_raydium_quotes_request,
            GetRaydiumQuotesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_pump_fun_quotes(
        self,
        get_pump_fun_quotes_request: "GetPumpFunQuotesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetPumpFunQuotesResponse":
        return await self._unary_unary(
            "/api.Api/GetPumpFunQuotes",
            get_pump_fun_quotes_request,
            GetPumpFunQuotesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_raydium_cpmm_quotes(
        self,
        get_raydium_cpmm_quotes_request: "GetRaydiumCpmmQuotesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetRaydiumCpmmQuotesResponse":
        return await self._unary_unary(
            "/api.Api/GetRaydiumCPMMQuotes",
            get_raydium_cpmm_quotes_request,
            GetRaydiumCpmmQuotesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_raydium_prices(
        self,
        get_raydium_prices_request: "GetRaydiumPricesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetRaydiumPricesResponse":
        return await self._unary_unary(
            "/api.Api/GetRaydiumPrices",
            get_raydium_prices_request,
            GetRaydiumPricesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_raydium_clmm_quotes(
        self,
        get_raydium_clmm_quotes_request: "GetRaydiumClmmQuotesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetRaydiumClmmQuotesResponse":
        return await self._unary_unary(
            "/api.Api/GetRaydiumCLMMQuotes",
            get_raydium_clmm_quotes_request,
            GetRaydiumClmmQuotesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_raydium_clmm_pools(
        self,
        get_raydium_clmm_pools_request: "GetRaydiumClmmPoolsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetRaydiumClmmPoolsResponse":
        return await self._unary_unary(
            "/api.Api/GetRaydiumCLMMPools",
            get_raydium_clmm_pools_request,
            GetRaydiumClmmPoolsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_raydium_clmm_swap(
        self,
        post_raydium_swap_request: "PostRaydiumSwapRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostRaydiumSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostRaydiumCLMMSwap",
            post_raydium_swap_request,
            PostRaydiumSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_raydium_clmm_route_swap(
        self,
        post_raydium_route_swap_request: "PostRaydiumRouteSwapRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostRaydiumRouteSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostRaydiumCLMMRouteSwap",
            post_raydium_route_swap_request,
            PostRaydiumRouteSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_raydium_swap(
        self,
        post_raydium_swap_request: "PostRaydiumSwapRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostRaydiumSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostRaydiumSwap",
            post_raydium_swap_request,
            PostRaydiumSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_raydium_route_swap(
        self,
        post_raydium_route_swap_request: "PostRaydiumRouteSwapRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostRaydiumRouteSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostRaydiumRouteSwap",
            post_raydium_route_swap_request,
            PostRaydiumRouteSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_raydium_cpmm_swap(
        self,
        post_raydium_cpmm_swap_request: "PostRaydiumCpmmSwapRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostRaydiumCpmmSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostRaydiumCPMMSwap",
            post_raydium_cpmm_swap_request,
            PostRaydiumCpmmSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_jupiter_quotes(
        self,
        get_jupiter_quotes_request: "GetJupiterQuotesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetJupiterQuotesResponse":
        return await self._unary_unary(
            "/api.Api/GetJupiterQuotes",
            get_jupiter_quotes_request,
            GetJupiterQuotesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_jupiter_prices(
        self,
        get_jupiter_prices_request: "GetJupiterPricesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetJupiterPricesResponse":
        return await self._unary_unary(
            "/api.Api/GetJupiterPrices",
            get_jupiter_prices_request,
            GetJupiterPricesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_jupiter_swap(
        self,
        post_jupiter_swap_request: "PostJupiterSwapRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostJupiterSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostJupiterSwap",
            post_jupiter_swap_request,
            PostJupiterSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_raydium_swap_instructions(
        self,
        post_raydium_swap_instructions_request: "PostRaydiumSwapInstructionsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostRaydiumSwapInstructionsResponse":
        return await self._unary_unary(
            "/api.Api/PostRaydiumSwapInstructions",
            post_raydium_swap_instructions_request,
            PostRaydiumSwapInstructionsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_jupiter_swap_instructions(
        self,
        post_jupiter_swap_instructions_request: "PostJupiterSwapInstructionsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostJupiterSwapInstructionsResponse":
        return await self._unary_unary(
            "/api.Api/PostJupiterSwapInstructions",
            post_jupiter_swap_instructions_request,
            PostJupiterSwapInstructionsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_jupiter_route_swap(
        self,
        post_jupiter_route_swap_request: "PostJupiterRouteSwapRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostJupiterRouteSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostJupiterRouteSwap",
            post_jupiter_route_swap_request,
            PostJupiterRouteSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_markets_v2(
        self,
        get_markets_request_v2: "GetMarketsRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetMarketsResponseV2":
        return await self._unary_unary(
            "/api.Api/GetMarketsV2",
            get_markets_request_v2,
            GetMarketsResponseV2,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_tickers_v2(
        self,
        get_tickers_request_v2: "GetTickersRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetTickersResponseV2":
        return await self._unary_unary(
            "/api.Api/GetTickersV2",
            get_tickers_request_v2,
            GetTickersResponseV2,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_orderbook_v2(
        self,
        get_orderbook_request_v2: "GetOrderbookRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetOrderbookResponseV2":
        return await self._unary_unary(
            "/api.Api/GetOrderbookV2",
            get_orderbook_request_v2,
            GetOrderbookResponseV2,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_market_depth_v2(
        self,
        get_market_depth_request_v2: "GetMarketDepthRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetMarketDepthResponseV2":
        return await self._unary_unary(
            "/api.Api/GetMarketDepthV2",
            get_market_depth_request_v2,
            GetMarketDepthResponseV2,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_order_v2(
        self,
        post_order_request_v2: "PostOrderRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostOrderResponse":
        return await self._unary_unary(
            "/api.Api/PostOrderV2",
            post_order_request_v2,
            PostOrderResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_cancel_order_v2(
        self,
        post_cancel_order_request_v2: "PostCancelOrderRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostCancelOrderResponseV2":
        return await self._unary_unary(
            "/api.Api/PostCancelOrderV2",
            post_cancel_order_request_v2,
            PostCancelOrderResponseV2,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_replace_order_v2(
        self,
        post_replace_order_request_v2: "PostReplaceOrderRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostOrderResponse":
        return await self._unary_unary(
            "/api.Api/PostReplaceOrderV2",
            post_replace_order_request_v2,
            PostOrderResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_zeta_cross_margin_account(
        self,
        post_zeta_cross_margin_account_request: "PostZetaCrossMarginAccountRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostZetaCrossMarginAccountResponse":
        return await self._unary_unary(
            "/api.Api/PostZetaCrossMarginAccount",
            post_zeta_cross_margin_account_request,
            PostZetaCrossMarginAccountResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_settle_v2(
        self,
        post_settle_request_v2: "PostSettleRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostSettleResponse":
        return await self._unary_unary(
            "/api.Api/PostSettleV2",
            post_settle_request_v2,
            PostSettleResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_open_orders_v2(
        self,
        get_open_orders_request_v2: "GetOpenOrdersRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetOpenOrdersResponseV2":
        return await self._unary_unary(
            "/api.Api/GetOpenOrdersV2",
            get_open_orders_request_v2,
            GetOpenOrdersResponseV2,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_unsettled_v2(
        self,
        get_unsettled_request_v2: "GetUnsettledRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetUnsettledResponse":
        return await self._unary_unary(
            "/api.Api/GetUnsettledV2",
            get_unsettled_request_v2,
            GetUnsettledResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_price(
        self,
        get_price_request: "GetPriceRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetPriceResponse":
        return await self._unary_unary(
            "/api.Api/GetPrice",
            get_price_request,
            GetPriceResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_markets(
        self,
        get_markets_request: "GetMarketsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetMarketsResponse":
        return await self._unary_unary(
            "/api.Api/GetMarkets",
            get_markets_request,
            GetMarketsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_pools(
        self,
        get_pools_request: "GetPoolsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetPoolsResponse":
        return await self._unary_unary(
            "/api.Api/GetPools",
            get_pools_request,
            GetPoolsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_tickers(
        self,
        get_tickers_request: "GetTickersRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetTickersResponse":
        return await self._unary_unary(
            "/api.Api/GetTickers",
            get_tickers_request,
            GetTickersResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_kline(
        self,
        get_kline_request: "GetKlineRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetKlineResponse":
        return await self._unary_unary(
            "/api.Api/GetKline",
            get_kline_request,
            GetKlineResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_orderbook(
        self,
        get_orderbook_request: "GetOrderbookRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetOrderbookResponse":
        return await self._unary_unary(
            "/api.Api/GetOrderbook",
            get_orderbook_request,
            GetOrderbookResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_market_depth(
        self,
        get_market_depth_request: "GetMarketDepthRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetMarketDepthResponse":
        return await self._unary_unary(
            "/api.Api/GetMarketDepth",
            get_market_depth_request,
            GetMarketDepthResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_trades(
        self,
        get_trades_request: "GetTradesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetTradesResponse":
        return await self._unary_unary(
            "/api.Api/GetTrades",
            get_trades_request,
            GetTradesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_quotes(
        self,
        get_quotes_request: "GetQuotesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetQuotesResponse":
        return await self._unary_unary(
            "/api.Api/GetQuotes",
            get_quotes_request,
            GetQuotesResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_server_time(
        self,
        get_server_time_request: "GetServerTimeRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetServerTimeResponse":
        return await self._unary_unary(
            "/api.Api/GetServerTime",
            get_server_time_request,
            GetServerTimeResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_recent_block_hash(
        self,
        get_recent_block_hash_request: "GetRecentBlockHashRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetRecentBlockHashResponse":
        return await self._unary_unary(
            "/api.Api/GetRecentBlockHash",
            get_recent_block_hash_request,
            GetRecentBlockHashResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_recent_block_hash_v2(
        self,
        get_recent_block_hash_request_v2: "GetRecentBlockHashRequestV2",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetRecentBlockHashResponseV2":
        return await self._unary_unary(
            "/api.Api/GetRecentBlockHashV2",
            get_recent_block_hash_request_v2,
            GetRecentBlockHashResponseV2,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_priority_fee(
        self,
        get_priority_fee_request: "GetPriorityFeeRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetPriorityFeeResponse":
        return await self._unary_unary(
            "/api.Api/GetPriorityFee",
            get_priority_fee_request,
            GetPriorityFeeResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_priority_fee_by_program(
        self,
        get_priority_fee_by_program_request: "GetPriorityFeeByProgramRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetPriorityFeeByProgramResponse":
        return await self._unary_unary(
            "/api.Api/GetPriorityFeeByProgram",
            get_priority_fee_by_program_request,
            GetPriorityFeeByProgramResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_account_balance(
        self,
        get_account_balance_request: "GetAccountBalanceRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetAccountBalanceResponse":
        return await self._unary_unary(
            "/api.Api/GetAccountBalance",
            get_account_balance_request,
            GetAccountBalanceResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_token_accounts(
        self,
        get_token_accounts_request: "GetTokenAccountsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetTokenAccountsResponse":
        return await self._unary_unary(
            "/api.Api/GetTokenAccounts",
            get_token_accounts_request,
            GetTokenAccountsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_account_balance_v2(
        self,
        get_account_balance_request: "GetAccountBalanceRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetAccountBalanceResponse":
        return await self._unary_unary(
            "/api.Api/GetAccountBalanceV2",
            get_account_balance_request,
            GetAccountBalanceResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_order(
        self,
        post_order_request: "PostOrderRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostOrderResponse":
        return await self._unary_unary(
            "/api.Api/PostOrder",
            post_order_request,
            PostOrderResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_submit(
        self,
        post_submit_request: "PostSubmitRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostSubmitResponse":
        return await self._unary_unary(
            "/api.Api/PostSubmit",
            post_submit_request,
            PostSubmitResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_submit_batch(
        self,
        post_submit_batch_request: "PostSubmitBatchRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostSubmitBatchResponse":
        return await self._unary_unary(
            "/api.Api/PostSubmitBatch",
            post_submit_batch_request,
            PostSubmitBatchResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_cancel_order(
        self,
        post_cancel_order_request: "PostCancelOrderRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostCancelOrderResponse":
        return await self._unary_unary(
            "/api.Api/PostCancelOrder",
            post_cancel_order_request,
            PostCancelOrderResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_cancel_by_client_order_id(
        self,
        post_cancel_by_client_order_id_request: "PostCancelByClientOrderIdRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostCancelOrderResponse":
        return await self._unary_unary(
            "/api.Api/PostCancelByClientOrderID",
            post_cancel_by_client_order_id_request,
            PostCancelOrderResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_cancel_all(
        self,
        post_cancel_all_request: "PostCancelAllRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostCancelAllResponse":
        return await self._unary_unary(
            "/api.Api/PostCancelAll",
            post_cancel_all_request,
            PostCancelAllResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_replace_by_client_order_id(
        self,
        post_order_request: "PostOrderRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostOrderResponse":
        return await self._unary_unary(
            "/api.Api/PostReplaceByClientOrderID",
            post_order_request,
            PostOrderResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_replace_order(
        self,
        post_replace_order_request: "PostReplaceOrderRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostOrderResponse":
        return await self._unary_unary(
            "/api.Api/PostReplaceOrder",
            post_replace_order_request,
            PostOrderResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_settle(
        self,
        post_settle_request: "PostSettleRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostSettleResponse":
        return await self._unary_unary(
            "/api.Api/PostSettle",
            post_settle_request,
            PostSettleResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_trade_swap(
        self,
        trade_swap_request: "TradeSwapRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "TradeSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostTradeSwap",
            trade_swap_request,
            TradeSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_orders(
        self,
        get_orders_request: "GetOrdersRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetOrdersResponse":
        return await self._unary_unary(
            "/api.Api/GetOrders",
            get_orders_request,
            GetOrdersResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_open_orders(
        self,
        get_open_orders_request: "GetOpenOrdersRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetOpenOrdersResponse":
        return await self._unary_unary(
            "/api.Api/GetOpenOrders",
            get_open_orders_request,
            GetOpenOrdersResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_order_by_id(
        self,
        get_order_by_id_request: "GetOrderByIdRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetOrderByIdResponse":
        return await self._unary_unary(
            "/api.Api/GetOrderByID",
            get_order_by_id_request,
            GetOrderByIdResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_unsettled(
        self,
        get_unsettled_request: "GetUnsettledRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetUnsettledResponse":
        return await self._unary_unary(
            "/api.Api/GetUnsettled",
            get_unsettled_request,
            GetUnsettledResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_route_trade_swap(
        self,
        route_trade_swap_request: "RouteTradeSwapRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "TradeSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostRouteTradeSwap",
            route_trade_swap_request,
            TradeSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_orderbooks_stream(
        self,
        get_orderbooks_request: "GetOrderbooksRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetOrderbooksStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetOrderbooksStream",
            get_orderbooks_request,
            GetOrderbooksStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_market_depths_stream(
        self,
        get_market_depths_request: "GetMarketDepthsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetMarketDepthsStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetMarketDepthsStream",
            get_market_depths_request,
            GetMarketDepthsStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_tickers_stream(
        self,
        get_tickers_stream_request: "GetTickersStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetTickersStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetTickersStream",
            get_tickers_stream_request,
            GetTickersStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_zeta_transaction_stream(
        self,
        get_zeta_transaction_stream_request: "GetZetaTransactionStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetZetaTransactionStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetZetaTransactionStream",
            get_zeta_transaction_stream_request,
            GetZetaTransactionStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_trades_stream(
        self,
        get_trades_request: "GetTradesRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetTradesStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetTradesStream",
            get_trades_request,
            GetTradesStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_order_status_stream(
        self,
        get_order_status_stream_request: "GetOrderStatusStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetOrderStatusStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetOrderStatusStream",
            get_order_status_stream_request,
            GetOrderStatusStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_recent_block_hash_stream(
        self,
        get_recent_block_hash_request: "GetRecentBlockHashRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetRecentBlockHashResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetRecentBlockHashStream",
            get_recent_block_hash_request,
            GetRecentBlockHashResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_block_stream(
        self,
        get_block_stream_request: "GetBlockStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetBlockStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetBlockStream",
            get_block_stream_request,
            GetBlockStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_priority_fee_stream(
        self,
        get_priority_fee_request: "GetPriorityFeeRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetPriorityFeeResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetPriorityFeeStream",
            get_priority_fee_request,
            GetPriorityFeeResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_priority_fee_by_program_stream(
        self,
        get_priority_fee_by_program_request: "GetPriorityFeeByProgramRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetPriorityFeeByProgramResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetPriorityFeeByProgramStream",
            get_priority_fee_by_program_request,
            GetPriorityFeeByProgramResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_bundle_tip_stream(
        self,
        get_bundle_tip_request: "GetBundleTipRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetBundleTipResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetBundleTipStream",
            get_bundle_tip_request,
            GetBundleTipResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_quotes_stream(
        self,
        get_quotes_stream_request: "GetQuotesStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetQuotesStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetQuotesStream",
            get_quotes_stream_request,
            GetQuotesStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_pool_reserves_stream(
        self,
        get_pool_reserves_stream_request: "GetPoolReservesStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetPoolReservesStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetPoolReservesStream",
            get_pool_reserves_stream_request,
            GetPoolReservesStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_prices_stream(
        self,
        get_prices_stream_request: "GetPricesStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetPricesStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetPricesStream",
            get_prices_stream_request,
            GetPricesStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_new_raydium_pools_stream(
        self,
        get_new_raydium_pools_request: "GetNewRaydiumPoolsRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetNewRaydiumPoolsResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetNewRaydiumPoolsStream",
            get_new_raydium_pools_request,
            GetNewRaydiumPoolsResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_new_raydium_pools_by_transaction_stream(
        self,
        get_new_raydium_pools_by_transaction_request: "GetNewRaydiumPoolsByTransactionRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetNewRaydiumPoolsByTransactionResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetNewRaydiumPoolsByTransactionStream",
            get_new_raydium_pools_by_transaction_request,
            GetNewRaydiumPoolsByTransactionResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_swaps_stream(
        self,
        get_swaps_stream_request: "GetSwapsStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetSwapsStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetSwapsStream",
            get_swaps_stream_request,
            GetSwapsStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_pump_fun_swaps_stream(
        self,
        get_pump_fun_swaps_stream_request: "GetPumpFunSwapsStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetPumpFunSwapsStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetPumpFunSwapsStream",
            get_pump_fun_swaps_stream_request,
            GetPumpFunSwapsStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_pump_fun_new_tokens_stream(
        self,
        get_pump_fun_new_tokens_stream_request: "GetPumpFunNewTokensStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetPumpFunNewTokensStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetPumpFunNewTokensStream",
            get_pump_fun_new_tokens_stream_request,
            GetPumpFunNewTokensStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_pump_fun_new_amm_pool_stream(
        self,
        get_pump_fun_new_amm_pool_stream_request: "GetPumpFunNewAmmPoolStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetPumpFunNewAmmPoolStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetPumpFunNewAmmPoolStream",
            get_pump_fun_new_amm_pool_stream_request,
            GetPumpFunNewAmmPoolStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def get_pump_fun_amm_swap_stream(
        self,
        get_pump_fun_amm_swap_stream_request: "GetPumpFunAmmSwapStreamRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> AsyncIterator[GetPumpFunAmmSwapStreamResponse]:
        async for response in self._unary_stream(
            "/api.Api/GetPumpFunAMMSwapStream",
            get_pump_fun_amm_swap_stream_request,
            GetPumpFunAmmSwapStreamResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        ):
            yield response

    async def post_pump_fun_swap(
        self,
        post_pump_fun_swap_request: "PostPumpFunSwapRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostPumpFunSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostPumpFunSwap",
            post_pump_fun_swap_request,
            PostPumpFunSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def post_pump_fun_swap_sol(
        self,
        post_pump_fun_swap_request_sol: "PostPumpFunSwapRequestSol",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "PostPumpFunSwapResponse":
        return await self._unary_unary(
            "/api.Api/PostPumpFunSwapSol",
            post_pump_fun_swap_request_sol,
            PostPumpFunSwapResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )

    async def get_leader_schedule(
        self,
        get_leader_schedule_request: "GetLeaderScheduleRequest",
        *,
        timeout: Optional[float] = None,
        deadline: Optional["Deadline"] = None,
        metadata: Optional["MetadataLike"] = None
    ) -> "GetLeaderScheduleResponse":
        return await self._unary_unary(
            "/api.Api/GetLeaderSchedule",
            get_leader_schedule_request,
            GetLeaderScheduleResponse,
            timeout=timeout,
            deadline=deadline,
            metadata=metadata,
        )


class ApiBase(ServiceBase):

    async def get_rate_limit(
        self, get_rate_limit_request: "GetRateLimitRequest"
    ) -> "GetRateLimitResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_transaction(
        self, get_transaction_request: "GetTransactionRequest"
    ) -> "GetTransactionResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_submit_v2(
        self, post_submit_request: "PostSubmitRequest"
    ) -> "PostSubmitResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_submit_batch_v2(
        self, post_submit_batch_request: "PostSubmitBatchRequest"
    ) -> "PostSubmitBatchResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_submit_snipe_v2(
        self, post_submit_snipe_request: "PostSubmitSnipeRequest"
    ) -> "PostSubmitSnipeResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_submit_paladin_v2(
        self, post_submit_paladin_request: "PostSubmitPaladinRequest"
    ) -> "PostSubmitResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_raydium_pools(
        self, get_raydium_pools_request: "GetRaydiumPoolsRequest"
    ) -> "GetRaydiumPoolsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_raydium_pool_reserve(
        self, get_raydium_pool_reserve_request: "GetRaydiumPoolReserveRequest"
    ) -> "GetRaydiumPoolReserveResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_raydium_quotes(
        self, get_raydium_quotes_request: "GetRaydiumQuotesRequest"
    ) -> "GetRaydiumQuotesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_pump_fun_quotes(
        self, get_pump_fun_quotes_request: "GetPumpFunQuotesRequest"
    ) -> "GetPumpFunQuotesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_raydium_cpmm_quotes(
        self, get_raydium_cpmm_quotes_request: "GetRaydiumCpmmQuotesRequest"
    ) -> "GetRaydiumCpmmQuotesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_raydium_prices(
        self, get_raydium_prices_request: "GetRaydiumPricesRequest"
    ) -> "GetRaydiumPricesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_raydium_clmm_quotes(
        self, get_raydium_clmm_quotes_request: "GetRaydiumClmmQuotesRequest"
    ) -> "GetRaydiumClmmQuotesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_raydium_clmm_pools(
        self, get_raydium_clmm_pools_request: "GetRaydiumClmmPoolsRequest"
    ) -> "GetRaydiumClmmPoolsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_raydium_clmm_swap(
        self, post_raydium_swap_request: "PostRaydiumSwapRequest"
    ) -> "PostRaydiumSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_raydium_clmm_route_swap(
        self, post_raydium_route_swap_request: "PostRaydiumRouteSwapRequest"
    ) -> "PostRaydiumRouteSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_raydium_swap(
        self, post_raydium_swap_request: "PostRaydiumSwapRequest"
    ) -> "PostRaydiumSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_raydium_route_swap(
        self, post_raydium_route_swap_request: "PostRaydiumRouteSwapRequest"
    ) -> "PostRaydiumRouteSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_raydium_cpmm_swap(
        self, post_raydium_cpmm_swap_request: "PostRaydiumCpmmSwapRequest"
    ) -> "PostRaydiumCpmmSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_jupiter_quotes(
        self, get_jupiter_quotes_request: "GetJupiterQuotesRequest"
    ) -> "GetJupiterQuotesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_jupiter_prices(
        self, get_jupiter_prices_request: "GetJupiterPricesRequest"
    ) -> "GetJupiterPricesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_jupiter_swap(
        self, post_jupiter_swap_request: "PostJupiterSwapRequest"
    ) -> "PostJupiterSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_raydium_swap_instructions(
        self,
        post_raydium_swap_instructions_request: "PostRaydiumSwapInstructionsRequest",
    ) -> "PostRaydiumSwapInstructionsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_jupiter_swap_instructions(
        self,
        post_jupiter_swap_instructions_request: "PostJupiterSwapInstructionsRequest",
    ) -> "PostJupiterSwapInstructionsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_jupiter_route_swap(
        self, post_jupiter_route_swap_request: "PostJupiterRouteSwapRequest"
    ) -> "PostJupiterRouteSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_markets_v2(
        self, get_markets_request_v2: "GetMarketsRequestV2"
    ) -> "GetMarketsResponseV2":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_tickers_v2(
        self, get_tickers_request_v2: "GetTickersRequestV2"
    ) -> "GetTickersResponseV2":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_orderbook_v2(
        self, get_orderbook_request_v2: "GetOrderbookRequestV2"
    ) -> "GetOrderbookResponseV2":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_market_depth_v2(
        self, get_market_depth_request_v2: "GetMarketDepthRequestV2"
    ) -> "GetMarketDepthResponseV2":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_order_v2(
        self, post_order_request_v2: "PostOrderRequestV2"
    ) -> "PostOrderResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_cancel_order_v2(
        self, post_cancel_order_request_v2: "PostCancelOrderRequestV2"
    ) -> "PostCancelOrderResponseV2":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_replace_order_v2(
        self, post_replace_order_request_v2: "PostReplaceOrderRequestV2"
    ) -> "PostOrderResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_zeta_cross_margin_account(
        self,
        post_zeta_cross_margin_account_request: "PostZetaCrossMarginAccountRequest",
    ) -> "PostZetaCrossMarginAccountResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_settle_v2(
        self, post_settle_request_v2: "PostSettleRequestV2"
    ) -> "PostSettleResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_open_orders_v2(
        self, get_open_orders_request_v2: "GetOpenOrdersRequestV2"
    ) -> "GetOpenOrdersResponseV2":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_unsettled_v2(
        self, get_unsettled_request_v2: "GetUnsettledRequestV2"
    ) -> "GetUnsettledResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_price(
        self, get_price_request: "GetPriceRequest"
    ) -> "GetPriceResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_markets(
        self, get_markets_request: "GetMarketsRequest"
    ) -> "GetMarketsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_pools(
        self, get_pools_request: "GetPoolsRequest"
    ) -> "GetPoolsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_tickers(
        self, get_tickers_request: "GetTickersRequest"
    ) -> "GetTickersResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_kline(
        self, get_kline_request: "GetKlineRequest"
    ) -> "GetKlineResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_orderbook(
        self, get_orderbook_request: "GetOrderbookRequest"
    ) -> "GetOrderbookResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_market_depth(
        self, get_market_depth_request: "GetMarketDepthRequest"
    ) -> "GetMarketDepthResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_trades(
        self, get_trades_request: "GetTradesRequest"
    ) -> "GetTradesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_quotes(
        self, get_quotes_request: "GetQuotesRequest"
    ) -> "GetQuotesResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_server_time(
        self, get_server_time_request: "GetServerTimeRequest"
    ) -> "GetServerTimeResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_recent_block_hash(
        self, get_recent_block_hash_request: "GetRecentBlockHashRequest"
    ) -> "GetRecentBlockHashResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_recent_block_hash_v2(
        self, get_recent_block_hash_request_v2: "GetRecentBlockHashRequestV2"
    ) -> "GetRecentBlockHashResponseV2":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_priority_fee(
        self, get_priority_fee_request: "GetPriorityFeeRequest"
    ) -> "GetPriorityFeeResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_priority_fee_by_program(
        self, get_priority_fee_by_program_request: "GetPriorityFeeByProgramRequest"
    ) -> "GetPriorityFeeByProgramResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_account_balance(
        self, get_account_balance_request: "GetAccountBalanceRequest"
    ) -> "GetAccountBalanceResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_token_accounts(
        self, get_token_accounts_request: "GetTokenAccountsRequest"
    ) -> "GetTokenAccountsResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_account_balance_v2(
        self, get_account_balance_request: "GetAccountBalanceRequest"
    ) -> "GetAccountBalanceResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_order(
        self, post_order_request: "PostOrderRequest"
    ) -> "PostOrderResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_submit(
        self, post_submit_request: "PostSubmitRequest"
    ) -> "PostSubmitResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_submit_batch(
        self, post_submit_batch_request: "PostSubmitBatchRequest"
    ) -> "PostSubmitBatchResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_cancel_order(
        self, post_cancel_order_request: "PostCancelOrderRequest"
    ) -> "PostCancelOrderResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_cancel_by_client_order_id(
        self, post_cancel_by_client_order_id_request: "PostCancelByClientOrderIdRequest"
    ) -> "PostCancelOrderResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_cancel_all(
        self, post_cancel_all_request: "PostCancelAllRequest"
    ) -> "PostCancelAllResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_replace_by_client_order_id(
        self, post_order_request: "PostOrderRequest"
    ) -> "PostOrderResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_replace_order(
        self, post_replace_order_request: "PostReplaceOrderRequest"
    ) -> "PostOrderResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_settle(
        self, post_settle_request: "PostSettleRequest"
    ) -> "PostSettleResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_trade_swap(
        self, trade_swap_request: "TradeSwapRequest"
    ) -> "TradeSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_orders(
        self, get_orders_request: "GetOrdersRequest"
    ) -> "GetOrdersResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_open_orders(
        self, get_open_orders_request: "GetOpenOrdersRequest"
    ) -> "GetOpenOrdersResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_order_by_id(
        self, get_order_by_id_request: "GetOrderByIdRequest"
    ) -> "GetOrderByIdResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_unsettled(
        self, get_unsettled_request: "GetUnsettledRequest"
    ) -> "GetUnsettledResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_route_trade_swap(
        self, route_trade_swap_request: "RouteTradeSwapRequest"
    ) -> "TradeSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_orderbooks_stream(
        self, get_orderbooks_request: "GetOrderbooksRequest"
    ) -> AsyncIterator[GetOrderbooksStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetOrderbooksStreamResponse()

    async def get_market_depths_stream(
        self, get_market_depths_request: "GetMarketDepthsRequest"
    ) -> AsyncIterator[GetMarketDepthsStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetMarketDepthsStreamResponse()

    async def get_tickers_stream(
        self, get_tickers_stream_request: "GetTickersStreamRequest"
    ) -> AsyncIterator[GetTickersStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetTickersStreamResponse()

    async def get_zeta_transaction_stream(
        self, get_zeta_transaction_stream_request: "GetZetaTransactionStreamRequest"
    ) -> AsyncIterator[GetZetaTransactionStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetZetaTransactionStreamResponse()

    async def get_trades_stream(
        self, get_trades_request: "GetTradesRequest"
    ) -> AsyncIterator[GetTradesStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetTradesStreamResponse()

    async def get_order_status_stream(
        self, get_order_status_stream_request: "GetOrderStatusStreamRequest"
    ) -> AsyncIterator[GetOrderStatusStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetOrderStatusStreamResponse()

    async def get_recent_block_hash_stream(
        self, get_recent_block_hash_request: "GetRecentBlockHashRequest"
    ) -> AsyncIterator[GetRecentBlockHashResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetRecentBlockHashResponse()

    async def get_block_stream(
        self, get_block_stream_request: "GetBlockStreamRequest"
    ) -> AsyncIterator[GetBlockStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetBlockStreamResponse()

    async def get_priority_fee_stream(
        self, get_priority_fee_request: "GetPriorityFeeRequest"
    ) -> AsyncIterator[GetPriorityFeeResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetPriorityFeeResponse()

    async def get_priority_fee_by_program_stream(
        self, get_priority_fee_by_program_request: "GetPriorityFeeByProgramRequest"
    ) -> AsyncIterator[GetPriorityFeeByProgramResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetPriorityFeeByProgramResponse()

    async def get_bundle_tip_stream(
        self, get_bundle_tip_request: "GetBundleTipRequest"
    ) -> AsyncIterator[GetBundleTipResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetBundleTipResponse()

    async def get_quotes_stream(
        self, get_quotes_stream_request: "GetQuotesStreamRequest"
    ) -> AsyncIterator[GetQuotesStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetQuotesStreamResponse()

    async def get_pool_reserves_stream(
        self, get_pool_reserves_stream_request: "GetPoolReservesStreamRequest"
    ) -> AsyncIterator[GetPoolReservesStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetPoolReservesStreamResponse()

    async def get_prices_stream(
        self, get_prices_stream_request: "GetPricesStreamRequest"
    ) -> AsyncIterator[GetPricesStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetPricesStreamResponse()

    async def get_new_raydium_pools_stream(
        self, get_new_raydium_pools_request: "GetNewRaydiumPoolsRequest"
    ) -> AsyncIterator[GetNewRaydiumPoolsResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetNewRaydiumPoolsResponse()

    async def get_new_raydium_pools_by_transaction_stream(
        self,
        get_new_raydium_pools_by_transaction_request: "GetNewRaydiumPoolsByTransactionRequest",
    ) -> AsyncIterator[GetNewRaydiumPoolsByTransactionResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetNewRaydiumPoolsByTransactionResponse()

    async def get_swaps_stream(
        self, get_swaps_stream_request: "GetSwapsStreamRequest"
    ) -> AsyncIterator[GetSwapsStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetSwapsStreamResponse()

    async def get_pump_fun_swaps_stream(
        self, get_pump_fun_swaps_stream_request: "GetPumpFunSwapsStreamRequest"
    ) -> AsyncIterator[GetPumpFunSwapsStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetPumpFunSwapsStreamResponse()

    async def get_pump_fun_new_tokens_stream(
        self, get_pump_fun_new_tokens_stream_request: "GetPumpFunNewTokensStreamRequest"
    ) -> AsyncIterator[GetPumpFunNewTokensStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetPumpFunNewTokensStreamResponse()

    async def get_pump_fun_new_amm_pool_stream(
        self,
        get_pump_fun_new_amm_pool_stream_request: "GetPumpFunNewAmmPoolStreamRequest",
    ) -> AsyncIterator[GetPumpFunNewAmmPoolStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetPumpFunNewAmmPoolStreamResponse()

    async def get_pump_fun_amm_swap_stream(
        self, get_pump_fun_amm_swap_stream_request: "GetPumpFunAmmSwapStreamRequest"
    ) -> AsyncIterator[GetPumpFunAmmSwapStreamResponse]:
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)
        yield GetPumpFunAmmSwapStreamResponse()

    async def post_pump_fun_swap(
        self, post_pump_fun_swap_request: "PostPumpFunSwapRequest"
    ) -> "PostPumpFunSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def post_pump_fun_swap_sol(
        self, post_pump_fun_swap_request_sol: "PostPumpFunSwapRequestSol"
    ) -> "PostPumpFunSwapResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def get_leader_schedule(
        self, get_leader_schedule_request: "GetLeaderScheduleRequest"
    ) -> "GetLeaderScheduleResponse":
        raise grpclib.GRPCError(grpclib.const.Status.UNIMPLEMENTED)

    async def __rpc_get_rate_limit(
        self, stream: "grpclib.server.Stream[GetRateLimitRequest, GetRateLimitResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_rate_limit(request)
        await stream.send_message(response)

    async def __rpc_get_transaction(
        self,
        stream: "grpclib.server.Stream[GetTransactionRequest, GetTransactionResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_transaction(request)
        await stream.send_message(response)

    async def __rpc_post_submit_v2(
        self, stream: "grpclib.server.Stream[PostSubmitRequest, PostSubmitResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_submit_v2(request)
        await stream.send_message(response)

    async def __rpc_post_submit_batch_v2(
        self,
        stream: "grpclib.server.Stream[PostSubmitBatchRequest, PostSubmitBatchResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_submit_batch_v2(request)
        await stream.send_message(response)

    async def __rpc_post_submit_snipe_v2(
        self,
        stream: "grpclib.server.Stream[PostSubmitSnipeRequest, PostSubmitSnipeResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_submit_snipe_v2(request)
        await stream.send_message(response)

    async def __rpc_post_submit_paladin_v2(
        self,
        stream: "grpclib.server.Stream[PostSubmitPaladinRequest, PostSubmitResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_submit_paladin_v2(request)
        await stream.send_message(response)

    async def __rpc_get_raydium_pools(
        self,
        stream: "grpclib.server.Stream[GetRaydiumPoolsRequest, GetRaydiumPoolsResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_raydium_pools(request)
        await stream.send_message(response)

    async def __rpc_get_raydium_pool_reserve(
        self,
        stream: "grpclib.server.Stream[GetRaydiumPoolReserveRequest, GetRaydiumPoolReserveResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_raydium_pool_reserve(request)
        await stream.send_message(response)

    async def __rpc_get_raydium_quotes(
        self,
        stream: "grpclib.server.Stream[GetRaydiumQuotesRequest, GetRaydiumQuotesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_raydium_quotes(request)
        await stream.send_message(response)

    async def __rpc_get_pump_fun_quotes(
        self,
        stream: "grpclib.server.Stream[GetPumpFunQuotesRequest, GetPumpFunQuotesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_pump_fun_quotes(request)
        await stream.send_message(response)

    async def __rpc_get_raydium_cpmm_quotes(
        self,
        stream: "grpclib.server.Stream[GetRaydiumCpmmQuotesRequest, GetRaydiumCpmmQuotesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_raydium_cpmm_quotes(request)
        await stream.send_message(response)

    async def __rpc_get_raydium_prices(
        self,
        stream: "grpclib.server.Stream[GetRaydiumPricesRequest, GetRaydiumPricesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_raydium_prices(request)
        await stream.send_message(response)

    async def __rpc_get_raydium_clmm_quotes(
        self,
        stream: "grpclib.server.Stream[GetRaydiumClmmQuotesRequest, GetRaydiumClmmQuotesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_raydium_clmm_quotes(request)
        await stream.send_message(response)

    async def __rpc_get_raydium_clmm_pools(
        self,
        stream: "grpclib.server.Stream[GetRaydiumClmmPoolsRequest, GetRaydiumClmmPoolsResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_raydium_clmm_pools(request)
        await stream.send_message(response)

    async def __rpc_post_raydium_clmm_swap(
        self,
        stream: "grpclib.server.Stream[PostRaydiumSwapRequest, PostRaydiumSwapResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_raydium_clmm_swap(request)
        await stream.send_message(response)

    async def __rpc_post_raydium_clmm_route_swap(
        self,
        stream: "grpclib.server.Stream[PostRaydiumRouteSwapRequest, PostRaydiumRouteSwapResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_raydium_clmm_route_swap(request)
        await stream.send_message(response)

    async def __rpc_post_raydium_swap(
        self,
        stream: "grpclib.server.Stream[PostRaydiumSwapRequest, PostRaydiumSwapResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_raydium_swap(request)
        await stream.send_message(response)

    async def __rpc_post_raydium_route_swap(
        self,
        stream: "grpclib.server.Stream[PostRaydiumRouteSwapRequest, PostRaydiumRouteSwapResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_raydium_route_swap(request)
        await stream.send_message(response)

    async def __rpc_post_raydium_cpmm_swap(
        self,
        stream: "grpclib.server.Stream[PostRaydiumCpmmSwapRequest, PostRaydiumCpmmSwapResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_raydium_cpmm_swap(request)
        await stream.send_message(response)

    async def __rpc_get_jupiter_quotes(
        self,
        stream: "grpclib.server.Stream[GetJupiterQuotesRequest, GetJupiterQuotesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_jupiter_quotes(request)
        await stream.send_message(response)

    async def __rpc_get_jupiter_prices(
        self,
        stream: "grpclib.server.Stream[GetJupiterPricesRequest, GetJupiterPricesResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_jupiter_prices(request)
        await stream.send_message(response)

    async def __rpc_post_jupiter_swap(
        self,
        stream: "grpclib.server.Stream[PostJupiterSwapRequest, PostJupiterSwapResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_jupiter_swap(request)
        await stream.send_message(response)

    async def __rpc_post_raydium_swap_instructions(
        self,
        stream: "grpclib.server.Stream[PostRaydiumSwapInstructionsRequest, PostRaydiumSwapInstructionsResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_raydium_swap_instructions(request)
        await stream.send_message(response)

    async def __rpc_post_jupiter_swap_instructions(
        self,
        stream: "grpclib.server.Stream[PostJupiterSwapInstructionsRequest, PostJupiterSwapInstructionsResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_jupiter_swap_instructions(request)
        await stream.send_message(response)

    async def __rpc_post_jupiter_route_swap(
        self,
        stream: "grpclib.server.Stream[PostJupiterRouteSwapRequest, PostJupiterRouteSwapResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_jupiter_route_swap(request)
        await stream.send_message(response)

    async def __rpc_get_markets_v2(
        self, stream: "grpclib.server.Stream[GetMarketsRequestV2, GetMarketsResponseV2]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_markets_v2(request)
        await stream.send_message(response)

    async def __rpc_get_tickers_v2(
        self, stream: "grpclib.server.Stream[GetTickersRequestV2, GetTickersResponseV2]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_tickers_v2(request)
        await stream.send_message(response)

    async def __rpc_get_orderbook_v2(
        self,
        stream: "grpclib.server.Stream[GetOrderbookRequestV2, GetOrderbookResponseV2]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_orderbook_v2(request)
        await stream.send_message(response)

    async def __rpc_get_market_depth_v2(
        self,
        stream: "grpclib.server.Stream[GetMarketDepthRequestV2, GetMarketDepthResponseV2]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_market_depth_v2(request)
        await stream.send_message(response)

    async def __rpc_post_order_v2(
        self, stream: "grpclib.server.Stream[PostOrderRequestV2, PostOrderResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_order_v2(request)
        await stream.send_message(response)

    async def __rpc_post_cancel_order_v2(
        self,
        stream: "grpclib.server.Stream[PostCancelOrderRequestV2, PostCancelOrderResponseV2]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_cancel_order_v2(request)
        await stream.send_message(response)

    async def __rpc_post_replace_order_v2(
        self,
        stream: "grpclib.server.Stream[PostReplaceOrderRequestV2, PostOrderResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_replace_order_v2(request)
        await stream.send_message(response)

    async def __rpc_post_zeta_cross_margin_account(
        self,
        stream: "grpclib.server.Stream[PostZetaCrossMarginAccountRequest, PostZetaCrossMarginAccountResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_zeta_cross_margin_account(request)
        await stream.send_message(response)

    async def __rpc_post_settle_v2(
        self, stream: "grpclib.server.Stream[PostSettleRequestV2, PostSettleResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_settle_v2(request)
        await stream.send_message(response)

    async def __rpc_get_open_orders_v2(
        self,
        stream: "grpclib.server.Stream[GetOpenOrdersRequestV2, GetOpenOrdersResponseV2]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_open_orders_v2(request)
        await stream.send_message(response)

    async def __rpc_get_unsettled_v2(
        self,
        stream: "grpclib.server.Stream[GetUnsettledRequestV2, GetUnsettledResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_unsettled_v2(request)
        await stream.send_message(response)

    async def __rpc_get_price(
        self, stream: "grpclib.server.Stream[GetPriceRequest, GetPriceResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_price(request)
        await stream.send_message(response)

    async def __rpc_get_markets(
        self, stream: "grpclib.server.Stream[GetMarketsRequest, GetMarketsResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_markets(request)
        await stream.send_message(response)

    async def __rpc_get_pools(
        self, stream: "grpclib.server.Stream[GetPoolsRequest, GetPoolsResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_pools(request)
        await stream.send_message(response)

    async def __rpc_get_tickers(
        self, stream: "grpclib.server.Stream[GetTickersRequest, GetTickersResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_tickers(request)
        await stream.send_message(response)

    async def __rpc_get_kline(
        self, stream: "grpclib.server.Stream[GetKlineRequest, GetKlineResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_kline(request)
        await stream.send_message(response)

    async def __rpc_get_orderbook(
        self, stream: "grpclib.server.Stream[GetOrderbookRequest, GetOrderbookResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_orderbook(request)
        await stream.send_message(response)

    async def __rpc_get_market_depth(
        self,
        stream: "grpclib.server.Stream[GetMarketDepthRequest, GetMarketDepthResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_market_depth(request)
        await stream.send_message(response)

    async def __rpc_get_trades(
        self, stream: "grpclib.server.Stream[GetTradesRequest, GetTradesResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_trades(request)
        await stream.send_message(response)

    async def __rpc_get_quotes(
        self, stream: "grpclib.server.Stream[GetQuotesRequest, GetQuotesResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_quotes(request)
        await stream.send_message(response)

    async def __rpc_get_server_time(
        self,
        stream: "grpclib.server.Stream[GetServerTimeRequest, GetServerTimeResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_server_time(request)
        await stream.send_message(response)

    async def __rpc_get_recent_block_hash(
        self,
        stream: "grpclib.server.Stream[GetRecentBlockHashRequest, GetRecentBlockHashResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_recent_block_hash(request)
        await stream.send_message(response)

    async def __rpc_get_recent_block_hash_v2(
        self,
        stream: "grpclib.server.Stream[GetRecentBlockHashRequestV2, GetRecentBlockHashResponseV2]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_recent_block_hash_v2(request)
        await stream.send_message(response)

    async def __rpc_get_priority_fee(
        self,
        stream: "grpclib.server.Stream[GetPriorityFeeRequest, GetPriorityFeeResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_priority_fee(request)
        await stream.send_message(response)

    async def __rpc_get_priority_fee_by_program(
        self,
        stream: "grpclib.server.Stream[GetPriorityFeeByProgramRequest, GetPriorityFeeByProgramResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_priority_fee_by_program(request)
        await stream.send_message(response)

    async def __rpc_get_account_balance(
        self,
        stream: "grpclib.server.Stream[GetAccountBalanceRequest, GetAccountBalanceResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_account_balance(request)
        await stream.send_message(response)

    async def __rpc_get_token_accounts(
        self,
        stream: "grpclib.server.Stream[GetTokenAccountsRequest, GetTokenAccountsResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_token_accounts(request)
        await stream.send_message(response)

    async def __rpc_get_account_balance_v2(
        self,
        stream: "grpclib.server.Stream[GetAccountBalanceRequest, GetAccountBalanceResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_account_balance_v2(request)
        await stream.send_message(response)

    async def __rpc_post_order(
        self, stream: "grpclib.server.Stream[PostOrderRequest, PostOrderResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_order(request)
        await stream.send_message(response)

    async def __rpc_post_submit(
        self, stream: "grpclib.server.Stream[PostSubmitRequest, PostSubmitResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_submit(request)
        await stream.send_message(response)

    async def __rpc_post_submit_batch(
        self,
        stream: "grpclib.server.Stream[PostSubmitBatchRequest, PostSubmitBatchResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_submit_batch(request)
        await stream.send_message(response)

    async def __rpc_post_cancel_order(
        self,
        stream: "grpclib.server.Stream[PostCancelOrderRequest, PostCancelOrderResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_cancel_order(request)
        await stream.send_message(response)

    async def __rpc_post_cancel_by_client_order_id(
        self,
        stream: "grpclib.server.Stream[PostCancelByClientOrderIdRequest, PostCancelOrderResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_cancel_by_client_order_id(request)
        await stream.send_message(response)

    async def __rpc_post_cancel_all(
        self,
        stream: "grpclib.server.Stream[PostCancelAllRequest, PostCancelAllResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_cancel_all(request)
        await stream.send_message(response)

    async def __rpc_post_replace_by_client_order_id(
        self, stream: "grpclib.server.Stream[PostOrderRequest, PostOrderResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_replace_by_client_order_id(request)
        await stream.send_message(response)

    async def __rpc_post_replace_order(
        self,
        stream: "grpclib.server.Stream[PostReplaceOrderRequest, PostOrderResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_replace_order(request)
        await stream.send_message(response)

    async def __rpc_post_settle(
        self, stream: "grpclib.server.Stream[PostSettleRequest, PostSettleResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_settle(request)
        await stream.send_message(response)

    async def __rpc_post_trade_swap(
        self, stream: "grpclib.server.Stream[TradeSwapRequest, TradeSwapResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_trade_swap(request)
        await stream.send_message(response)

    async def __rpc_get_orders(
        self, stream: "grpclib.server.Stream[GetOrdersRequest, GetOrdersResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_orders(request)
        await stream.send_message(response)

    async def __rpc_get_open_orders(
        self,
        stream: "grpclib.server.Stream[GetOpenOrdersRequest, GetOpenOrdersResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_open_orders(request)
        await stream.send_message(response)

    async def __rpc_get_order_by_id(
        self, stream: "grpclib.server.Stream[GetOrderByIdRequest, GetOrderByIdResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_order_by_id(request)
        await stream.send_message(response)

    async def __rpc_get_unsettled(
        self, stream: "grpclib.server.Stream[GetUnsettledRequest, GetUnsettledResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_unsettled(request)
        await stream.send_message(response)

    async def __rpc_post_route_trade_swap(
        self, stream: "grpclib.server.Stream[RouteTradeSwapRequest, TradeSwapResponse]"
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_route_trade_swap(request)
        await stream.send_message(response)

    async def __rpc_get_orderbooks_stream(
        self,
        stream: "grpclib.server.Stream[GetOrderbooksRequest, GetOrderbooksStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_orderbooks_stream,
            stream,
            request,
        )

    async def __rpc_get_market_depths_stream(
        self,
        stream: "grpclib.server.Stream[GetMarketDepthsRequest, GetMarketDepthsStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_market_depths_stream,
            stream,
            request,
        )

    async def __rpc_get_tickers_stream(
        self,
        stream: "grpclib.server.Stream[GetTickersStreamRequest, GetTickersStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_tickers_stream,
            stream,
            request,
        )

    async def __rpc_get_zeta_transaction_stream(
        self,
        stream: "grpclib.server.Stream[GetZetaTransactionStreamRequest, GetZetaTransactionStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_zeta_transaction_stream,
            stream,
            request,
        )

    async def __rpc_get_trades_stream(
        self, stream: "grpclib.server.Stream[GetTradesRequest, GetTradesStreamResponse]"
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_trades_stream,
            stream,
            request,
        )

    async def __rpc_get_order_status_stream(
        self,
        stream: "grpclib.server.Stream[GetOrderStatusStreamRequest, GetOrderStatusStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_order_status_stream,
            stream,
            request,
        )

    async def __rpc_get_recent_block_hash_stream(
        self,
        stream: "grpclib.server.Stream[GetRecentBlockHashRequest, GetRecentBlockHashResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_recent_block_hash_stream,
            stream,
            request,
        )

    async def __rpc_get_block_stream(
        self,
        stream: "grpclib.server.Stream[GetBlockStreamRequest, GetBlockStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_block_stream,
            stream,
            request,
        )

    async def __rpc_get_priority_fee_stream(
        self,
        stream: "grpclib.server.Stream[GetPriorityFeeRequest, GetPriorityFeeResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_priority_fee_stream,
            stream,
            request,
        )

    async def __rpc_get_priority_fee_by_program_stream(
        self,
        stream: "grpclib.server.Stream[GetPriorityFeeByProgramRequest, GetPriorityFeeByProgramResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_priority_fee_by_program_stream,
            stream,
            request,
        )

    async def __rpc_get_bundle_tip_stream(
        self, stream: "grpclib.server.Stream[GetBundleTipRequest, GetBundleTipResponse]"
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_bundle_tip_stream,
            stream,
            request,
        )

    async def __rpc_get_quotes_stream(
        self,
        stream: "grpclib.server.Stream[GetQuotesStreamRequest, GetQuotesStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_quotes_stream,
            stream,
            request,
        )

    async def __rpc_get_pool_reserves_stream(
        self,
        stream: "grpclib.server.Stream[GetPoolReservesStreamRequest, GetPoolReservesStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_pool_reserves_stream,
            stream,
            request,
        )

    async def __rpc_get_prices_stream(
        self,
        stream: "grpclib.server.Stream[GetPricesStreamRequest, GetPricesStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_prices_stream,
            stream,
            request,
        )

    async def __rpc_get_new_raydium_pools_stream(
        self,
        stream: "grpclib.server.Stream[GetNewRaydiumPoolsRequest, GetNewRaydiumPoolsResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_new_raydium_pools_stream,
            stream,
            request,
        )

    async def __rpc_get_new_raydium_pools_by_transaction_stream(
        self,
        stream: "grpclib.server.Stream[GetNewRaydiumPoolsByTransactionRequest, GetNewRaydiumPoolsByTransactionResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_new_raydium_pools_by_transaction_stream,
            stream,
            request,
        )

    async def __rpc_get_swaps_stream(
        self,
        stream: "grpclib.server.Stream[GetSwapsStreamRequest, GetSwapsStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_swaps_stream,
            stream,
            request,
        )

    async def __rpc_get_pump_fun_swaps_stream(
        self,
        stream: "grpclib.server.Stream[GetPumpFunSwapsStreamRequest, GetPumpFunSwapsStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_pump_fun_swaps_stream,
            stream,
            request,
        )

    async def __rpc_get_pump_fun_new_tokens_stream(
        self,
        stream: "grpclib.server.Stream[GetPumpFunNewTokensStreamRequest, GetPumpFunNewTokensStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_pump_fun_new_tokens_stream,
            stream,
            request,
        )

    async def __rpc_get_pump_fun_new_amm_pool_stream(
        self,
        stream: "grpclib.server.Stream[GetPumpFunNewAmmPoolStreamRequest, GetPumpFunNewAmmPoolStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_pump_fun_new_amm_pool_stream,
            stream,
            request,
        )

    async def __rpc_get_pump_fun_amm_swap_stream(
        self,
        stream: "grpclib.server.Stream[GetPumpFunAmmSwapStreamRequest, GetPumpFunAmmSwapStreamResponse]",
    ) -> None:
        request = await stream.recv_message()
        await self._call_rpc_handler_server_stream(
            self.get_pump_fun_amm_swap_stream,
            stream,
            request,
        )

    async def __rpc_post_pump_fun_swap(
        self,
        stream: "grpclib.server.Stream[PostPumpFunSwapRequest, PostPumpFunSwapResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_pump_fun_swap(request)
        await stream.send_message(response)

    async def __rpc_post_pump_fun_swap_sol(
        self,
        stream: "grpclib.server.Stream[PostPumpFunSwapRequestSol, PostPumpFunSwapResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.post_pump_fun_swap_sol(request)
        await stream.send_message(response)

    async def __rpc_get_leader_schedule(
        self,
        stream: "grpclib.server.Stream[GetLeaderScheduleRequest, GetLeaderScheduleResponse]",
    ) -> None:
        request = await stream.recv_message()
        response = await self.get_leader_schedule(request)
        await stream.send_message(response)

    def __mapping__(self) -> Dict[str, grpclib.const.Handler]:
        return {
            "/api.Api/GetRateLimit": grpclib.const.Handler(
                self.__rpc_get_rate_limit,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetRateLimitRequest,
                GetRateLimitResponse,
            ),
            "/api.Api/GetTransaction": grpclib.const.Handler(
                self.__rpc_get_transaction,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetTransactionRequest,
                GetTransactionResponse,
            ),
            "/api.Api/PostSubmitV2": grpclib.const.Handler(
                self.__rpc_post_submit_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostSubmitRequest,
                PostSubmitResponse,
            ),
            "/api.Api/PostSubmitBatchV2": grpclib.const.Handler(
                self.__rpc_post_submit_batch_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostSubmitBatchRequest,
                PostSubmitBatchResponse,
            ),
            "/api.Api/PostSubmitSnipeV2": grpclib.const.Handler(
                self.__rpc_post_submit_snipe_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostSubmitSnipeRequest,
                PostSubmitSnipeResponse,
            ),
            "/api.Api/PostSubmitPaladinV2": grpclib.const.Handler(
                self.__rpc_post_submit_paladin_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostSubmitPaladinRequest,
                PostSubmitResponse,
            ),
            "/api.Api/GetRaydiumPools": grpclib.const.Handler(
                self.__rpc_get_raydium_pools,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetRaydiumPoolsRequest,
                GetRaydiumPoolsResponse,
            ),
            "/api.Api/GetRaydiumPoolReserve": grpclib.const.Handler(
                self.__rpc_get_raydium_pool_reserve,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetRaydiumPoolReserveRequest,
                GetRaydiumPoolReserveResponse,
            ),
            "/api.Api/GetRaydiumQuotes": grpclib.const.Handler(
                self.__rpc_get_raydium_quotes,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetRaydiumQuotesRequest,
                GetRaydiumQuotesResponse,
            ),
            "/api.Api/GetPumpFunQuotes": grpclib.const.Handler(
                self.__rpc_get_pump_fun_quotes,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetPumpFunQuotesRequest,
                GetPumpFunQuotesResponse,
            ),
            "/api.Api/GetRaydiumCPMMQuotes": grpclib.const.Handler(
                self.__rpc_get_raydium_cpmm_quotes,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetRaydiumCpmmQuotesRequest,
                GetRaydiumCpmmQuotesResponse,
            ),
            "/api.Api/GetRaydiumPrices": grpclib.const.Handler(
                self.__rpc_get_raydium_prices,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetRaydiumPricesRequest,
                GetRaydiumPricesResponse,
            ),
            "/api.Api/GetRaydiumCLMMQuotes": grpclib.const.Handler(
                self.__rpc_get_raydium_clmm_quotes,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetRaydiumClmmQuotesRequest,
                GetRaydiumClmmQuotesResponse,
            ),
            "/api.Api/GetRaydiumCLMMPools": grpclib.const.Handler(
                self.__rpc_get_raydium_clmm_pools,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetRaydiumClmmPoolsRequest,
                GetRaydiumClmmPoolsResponse,
            ),
            "/api.Api/PostRaydiumCLMMSwap": grpclib.const.Handler(
                self.__rpc_post_raydium_clmm_swap,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostRaydiumSwapRequest,
                PostRaydiumSwapResponse,
            ),
            "/api.Api/PostRaydiumCLMMRouteSwap": grpclib.const.Handler(
                self.__rpc_post_raydium_clmm_route_swap,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostRaydiumRouteSwapRequest,
                PostRaydiumRouteSwapResponse,
            ),
            "/api.Api/PostRaydiumSwap": grpclib.const.Handler(
                self.__rpc_post_raydium_swap,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostRaydiumSwapRequest,
                PostRaydiumSwapResponse,
            ),
            "/api.Api/PostRaydiumRouteSwap": grpclib.const.Handler(
                self.__rpc_post_raydium_route_swap,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostRaydiumRouteSwapRequest,
                PostRaydiumRouteSwapResponse,
            ),
            "/api.Api/PostRaydiumCPMMSwap": grpclib.const.Handler(
                self.__rpc_post_raydium_cpmm_swap,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostRaydiumCpmmSwapRequest,
                PostRaydiumCpmmSwapResponse,
            ),
            "/api.Api/GetJupiterQuotes": grpclib.const.Handler(
                self.__rpc_get_jupiter_quotes,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetJupiterQuotesRequest,
                GetJupiterQuotesResponse,
            ),
            "/api.Api/GetJupiterPrices": grpclib.const.Handler(
                self.__rpc_get_jupiter_prices,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetJupiterPricesRequest,
                GetJupiterPricesResponse,
            ),
            "/api.Api/PostJupiterSwap": grpclib.const.Handler(
                self.__rpc_post_jupiter_swap,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostJupiterSwapRequest,
                PostJupiterSwapResponse,
            ),
            "/api.Api/PostRaydiumSwapInstructions": grpclib.const.Handler(
                self.__rpc_post_raydium_swap_instructions,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostRaydiumSwapInstructionsRequest,
                PostRaydiumSwapInstructionsResponse,
            ),
            "/api.Api/PostJupiterSwapInstructions": grpclib.const.Handler(
                self.__rpc_post_jupiter_swap_instructions,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostJupiterSwapInstructionsRequest,
                PostJupiterSwapInstructionsResponse,
            ),
            "/api.Api/PostJupiterRouteSwap": grpclib.const.Handler(
                self.__rpc_post_jupiter_route_swap,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostJupiterRouteSwapRequest,
                PostJupiterRouteSwapResponse,
            ),
            "/api.Api/GetMarketsV2": grpclib.const.Handler(
                self.__rpc_get_markets_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetMarketsRequestV2,
                GetMarketsResponseV2,
            ),
            "/api.Api/GetTickersV2": grpclib.const.Handler(
                self.__rpc_get_tickers_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetTickersRequestV2,
                GetTickersResponseV2,
            ),
            "/api.Api/GetOrderbookV2": grpclib.const.Handler(
                self.__rpc_get_orderbook_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetOrderbookRequestV2,
                GetOrderbookResponseV2,
            ),
            "/api.Api/GetMarketDepthV2": grpclib.const.Handler(
                self.__rpc_get_market_depth_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetMarketDepthRequestV2,
                GetMarketDepthResponseV2,
            ),
            "/api.Api/PostOrderV2": grpclib.const.Handler(
                self.__rpc_post_order_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostOrderRequestV2,
                PostOrderResponse,
            ),
            "/api.Api/PostCancelOrderV2": grpclib.const.Handler(
                self.__rpc_post_cancel_order_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostCancelOrderRequestV2,
                PostCancelOrderResponseV2,
            ),
            "/api.Api/PostReplaceOrderV2": grpclib.const.Handler(
                self.__rpc_post_replace_order_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostReplaceOrderRequestV2,
                PostOrderResponse,
            ),
            "/api.Api/PostZetaCrossMarginAccount": grpclib.const.Handler(
                self.__rpc_post_zeta_cross_margin_account,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostZetaCrossMarginAccountRequest,
                PostZetaCrossMarginAccountResponse,
            ),
            "/api.Api/PostSettleV2": grpclib.const.Handler(
                self.__rpc_post_settle_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostSettleRequestV2,
                PostSettleResponse,
            ),
            "/api.Api/GetOpenOrdersV2": grpclib.const.Handler(
                self.__rpc_get_open_orders_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetOpenOrdersRequestV2,
                GetOpenOrdersResponseV2,
            ),
            "/api.Api/GetUnsettledV2": grpclib.const.Handler(
                self.__rpc_get_unsettled_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetUnsettledRequestV2,
                GetUnsettledResponse,
            ),
            "/api.Api/GetPrice": grpclib.const.Handler(
                self.__rpc_get_price,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetPriceRequest,
                GetPriceResponse,
            ),
            "/api.Api/GetMarkets": grpclib.const.Handler(
                self.__rpc_get_markets,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetMarketsRequest,
                GetMarketsResponse,
            ),
            "/api.Api/GetPools": grpclib.const.Handler(
                self.__rpc_get_pools,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetPoolsRequest,
                GetPoolsResponse,
            ),
            "/api.Api/GetTickers": grpclib.const.Handler(
                self.__rpc_get_tickers,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetTickersRequest,
                GetTickersResponse,
            ),
            "/api.Api/GetKline": grpclib.const.Handler(
                self.__rpc_get_kline,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetKlineRequest,
                GetKlineResponse,
            ),
            "/api.Api/GetOrderbook": grpclib.const.Handler(
                self.__rpc_get_orderbook,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetOrderbookRequest,
                GetOrderbookResponse,
            ),
            "/api.Api/GetMarketDepth": grpclib.const.Handler(
                self.__rpc_get_market_depth,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetMarketDepthRequest,
                GetMarketDepthResponse,
            ),
            "/api.Api/GetTrades": grpclib.const.Handler(
                self.__rpc_get_trades,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetTradesRequest,
                GetTradesResponse,
            ),
            "/api.Api/GetQuotes": grpclib.const.Handler(
                self.__rpc_get_quotes,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetQuotesRequest,
                GetQuotesResponse,
            ),
            "/api.Api/GetServerTime": grpclib.const.Handler(
                self.__rpc_get_server_time,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetServerTimeRequest,
                GetServerTimeResponse,
            ),
            "/api.Api/GetRecentBlockHash": grpclib.const.Handler(
                self.__rpc_get_recent_block_hash,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetRecentBlockHashRequest,
                GetRecentBlockHashResponse,
            ),
            "/api.Api/GetRecentBlockHashV2": grpclib.const.Handler(
                self.__rpc_get_recent_block_hash_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetRecentBlockHashRequestV2,
                GetRecentBlockHashResponseV2,
            ),
            "/api.Api/GetPriorityFee": grpclib.const.Handler(
                self.__rpc_get_priority_fee,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetPriorityFeeRequest,
                GetPriorityFeeResponse,
            ),
            "/api.Api/GetPriorityFeeByProgram": grpclib.const.Handler(
                self.__rpc_get_priority_fee_by_program,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetPriorityFeeByProgramRequest,
                GetPriorityFeeByProgramResponse,
            ),
            "/api.Api/GetAccountBalance": grpclib.const.Handler(
                self.__rpc_get_account_balance,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetAccountBalanceRequest,
                GetAccountBalanceResponse,
            ),
            "/api.Api/GetTokenAccounts": grpclib.const.Handler(
                self.__rpc_get_token_accounts,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetTokenAccountsRequest,
                GetTokenAccountsResponse,
            ),
            "/api.Api/GetAccountBalanceV2": grpclib.const.Handler(
                self.__rpc_get_account_balance_v2,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetAccountBalanceRequest,
                GetAccountBalanceResponse,
            ),
            "/api.Api/PostOrder": grpclib.const.Handler(
                self.__rpc_post_order,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostOrderRequest,
                PostOrderResponse,
            ),
            "/api.Api/PostSubmit": grpclib.const.Handler(
                self.__rpc_post_submit,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostSubmitRequest,
                PostSubmitResponse,
            ),
            "/api.Api/PostSubmitBatch": grpclib.const.Handler(
                self.__rpc_post_submit_batch,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostSubmitBatchRequest,
                PostSubmitBatchResponse,
            ),
            "/api.Api/PostCancelOrder": grpclib.const.Handler(
                self.__rpc_post_cancel_order,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostCancelOrderRequest,
                PostCancelOrderResponse,
            ),
            "/api.Api/PostCancelByClientOrderID": grpclib.const.Handler(
                self.__rpc_post_cancel_by_client_order_id,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostCancelByClientOrderIdRequest,
                PostCancelOrderResponse,
            ),
            "/api.Api/PostCancelAll": grpclib.const.Handler(
                self.__rpc_post_cancel_all,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostCancelAllRequest,
                PostCancelAllResponse,
            ),
            "/api.Api/PostReplaceByClientOrderID": grpclib.const.Handler(
                self.__rpc_post_replace_by_client_order_id,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostOrderRequest,
                PostOrderResponse,
            ),
            "/api.Api/PostReplaceOrder": grpclib.const.Handler(
                self.__rpc_post_replace_order,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostReplaceOrderRequest,
                PostOrderResponse,
            ),
            "/api.Api/PostSettle": grpclib.const.Handler(
                self.__rpc_post_settle,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostSettleRequest,
                PostSettleResponse,
            ),
            "/api.Api/PostTradeSwap": grpclib.const.Handler(
                self.__rpc_post_trade_swap,
                grpclib.const.Cardinality.UNARY_UNARY,
                TradeSwapRequest,
                TradeSwapResponse,
            ),
            "/api.Api/GetOrders": grpclib.const.Handler(
                self.__rpc_get_orders,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetOrdersRequest,
                GetOrdersResponse,
            ),
            "/api.Api/GetOpenOrders": grpclib.const.Handler(
                self.__rpc_get_open_orders,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetOpenOrdersRequest,
                GetOpenOrdersResponse,
            ),
            "/api.Api/GetOrderByID": grpclib.const.Handler(
                self.__rpc_get_order_by_id,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetOrderByIdRequest,
                GetOrderByIdResponse,
            ),
            "/api.Api/GetUnsettled": grpclib.const.Handler(
                self.__rpc_get_unsettled,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetUnsettledRequest,
                GetUnsettledResponse,
            ),
            "/api.Api/PostRouteTradeSwap": grpclib.const.Handler(
                self.__rpc_post_route_trade_swap,
                grpclib.const.Cardinality.UNARY_UNARY,
                RouteTradeSwapRequest,
                TradeSwapResponse,
            ),
            "/api.Api/GetOrderbooksStream": grpclib.const.Handler(
                self.__rpc_get_orderbooks_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetOrderbooksRequest,
                GetOrderbooksStreamResponse,
            ),
            "/api.Api/GetMarketDepthsStream": grpclib.const.Handler(
                self.__rpc_get_market_depths_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetMarketDepthsRequest,
                GetMarketDepthsStreamResponse,
            ),
            "/api.Api/GetTickersStream": grpclib.const.Handler(
                self.__rpc_get_tickers_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetTickersStreamRequest,
                GetTickersStreamResponse,
            ),
            "/api.Api/GetZetaTransactionStream": grpclib.const.Handler(
                self.__rpc_get_zeta_transaction_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetZetaTransactionStreamRequest,
                GetZetaTransactionStreamResponse,
            ),
            "/api.Api/GetTradesStream": grpclib.const.Handler(
                self.__rpc_get_trades_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetTradesRequest,
                GetTradesStreamResponse,
            ),
            "/api.Api/GetOrderStatusStream": grpclib.const.Handler(
                self.__rpc_get_order_status_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetOrderStatusStreamRequest,
                GetOrderStatusStreamResponse,
            ),
            "/api.Api/GetRecentBlockHashStream": grpclib.const.Handler(
                self.__rpc_get_recent_block_hash_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetRecentBlockHashRequest,
                GetRecentBlockHashResponse,
            ),
            "/api.Api/GetBlockStream": grpclib.const.Handler(
                self.__rpc_get_block_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetBlockStreamRequest,
                GetBlockStreamResponse,
            ),
            "/api.Api/GetPriorityFeeStream": grpclib.const.Handler(
                self.__rpc_get_priority_fee_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetPriorityFeeRequest,
                GetPriorityFeeResponse,
            ),
            "/api.Api/GetPriorityFeeByProgramStream": grpclib.const.Handler(
                self.__rpc_get_priority_fee_by_program_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetPriorityFeeByProgramRequest,
                GetPriorityFeeByProgramResponse,
            ),
            "/api.Api/GetBundleTipStream": grpclib.const.Handler(
                self.__rpc_get_bundle_tip_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetBundleTipRequest,
                GetBundleTipResponse,
            ),
            "/api.Api/GetQuotesStream": grpclib.const.Handler(
                self.__rpc_get_quotes_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetQuotesStreamRequest,
                GetQuotesStreamResponse,
            ),
            "/api.Api/GetPoolReservesStream": grpclib.const.Handler(
                self.__rpc_get_pool_reserves_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetPoolReservesStreamRequest,
                GetPoolReservesStreamResponse,
            ),
            "/api.Api/GetPricesStream": grpclib.const.Handler(
                self.__rpc_get_prices_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetPricesStreamRequest,
                GetPricesStreamResponse,
            ),
            "/api.Api/GetNewRaydiumPoolsStream": grpclib.const.Handler(
                self.__rpc_get_new_raydium_pools_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetNewRaydiumPoolsRequest,
                GetNewRaydiumPoolsResponse,
            ),
            "/api.Api/GetNewRaydiumPoolsByTransactionStream": grpclib.const.Handler(
                self.__rpc_get_new_raydium_pools_by_transaction_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetNewRaydiumPoolsByTransactionRequest,
                GetNewRaydiumPoolsByTransactionResponse,
            ),
            "/api.Api/GetSwapsStream": grpclib.const.Handler(
                self.__rpc_get_swaps_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetSwapsStreamRequest,
                GetSwapsStreamResponse,
            ),
            "/api.Api/GetPumpFunSwapsStream": grpclib.const.Handler(
                self.__rpc_get_pump_fun_swaps_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetPumpFunSwapsStreamRequest,
                GetPumpFunSwapsStreamResponse,
            ),
            "/api.Api/GetPumpFunNewTokensStream": grpclib.const.Handler(
                self.__rpc_get_pump_fun_new_tokens_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetPumpFunNewTokensStreamRequest,
                GetPumpFunNewTokensStreamResponse,
            ),
            "/api.Api/GetPumpFunNewAmmPoolStream": grpclib.const.Handler(
                self.__rpc_get_pump_fun_new_amm_pool_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetPumpFunNewAmmPoolStreamRequest,
                GetPumpFunNewAmmPoolStreamResponse,
            ),
            "/api.Api/GetPumpFunAMMSwapStream": grpclib.const.Handler(
                self.__rpc_get_pump_fun_amm_swap_stream,
                grpclib.const.Cardinality.UNARY_STREAM,
                GetPumpFunAmmSwapStreamRequest,
                GetPumpFunAmmSwapStreamResponse,
            ),
            "/api.Api/PostPumpFunSwap": grpclib.const.Handler(
                self.__rpc_post_pump_fun_swap,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostPumpFunSwapRequest,
                PostPumpFunSwapResponse,
            ),
            "/api.Api/PostPumpFunSwapSol": grpclib.const.Handler(
                self.__rpc_post_pump_fun_swap_sol,
                grpclib.const.Cardinality.UNARY_UNARY,
                PostPumpFunSwapRequestSol,
                PostPumpFunSwapResponse,
            ),
            "/api.Api/GetLeaderSchedule": grpclib.const.Handler(
                self.__rpc_get_leader_schedule,
                grpclib.const.Cardinality.UNARY_UNARY,
                GetLeaderScheduleRequest,
                GetLeaderScheduleResponse,
            ),
        }
