@decibeltrade/sdk 0.1.1

package/src/read/index.ts

@@ -0,0 +1,271 @@
+import { AccountAddress, Aptos, AptosConfig, createObjectAddress } from "@aptos-labs/ts-sdk";
+import { ErrorEvent } from "isomorphic-ws";
+
+import { DecibelConfig, DecibelReaderDeps } from "../constants";
+import { AccountOverviewReader } from "./account-overview/account-overview.reader";
+import { CandlesticksReader } from "./candlesticks/candlesticks.reader";
+import { DelegationsReader } from "./delegations/delegations.reader";
+import { LeaderboardReader } from "./leaderboard/leaderboard.reader";
+import { MarketContextsReader } from "./market-contexts/market-contexts.reader";
+import { MarketDepthReader } from "./market-depth/market-depth.reader";
+import { MarketPricesReader } from "./market-prices/market-prices.reader";
+import { MarketTradesReader } from "./market-trades/market-trades.reader";
+import { MarketsReader } from "./markets/markets.reader";
+import { PortfolioChartReader } from "./portfolio-chart/portfolio-chart.reader";
+import { CrossedPosition } from "./types";
+import { UserActiveTwapsReader } from "./user-active-twaps/user-active-twaps.reader";
+import { UserBulkOrdersReader } from "./user-bulk-orders/user-bulk-orders.reader";
+import { UserFundingHistoryReader } from "./user-funding-history/user-funding-history.reader";
+import { UserNotificationsReader } from "./user-notifications/user-notifications.reader";
+import { UserOpenOrdersReader } from "./user-open-orders/user-open-orders.reader";
+import { UserOrderHistoryReader } from "./user-order-history/user-order-history.reader";
+import { UserPositionsReader } from "./user-positions/user-positions.reader";
+import { UserSubaccountsReader } from "./user-subaccounts/user-subaccounts.reader";
+import { UserTradeHistoryReader } from "./user-trade-history/user-trade-history.reader";
+import { VaultsReader } from "./vaults/vaults.reader";
+import { DecibelWsSubscription } from "./ws-subscription";
+
+export * from "./types";
+
+interface Cache {
+  usdcDecimals?: number;
+}
+
+export class DecibelReadDex {
+  readonly cache: Cache;
+  readonly deps: DecibelReaderDeps;
+  readonly accountOverview: AccountOverviewReader;
+  readonly markets: MarketsReader;
+  readonly marketContexts: MarketContextsReader;
+  readonly marketDepth: MarketDepthReader;
+  readonly marketPrices: MarketPricesReader;
+  readonly marketTrades: MarketTradesReader;
+  readonly userFundingHistory: UserFundingHistoryReader;
+  readonly userTradeHistory: UserTradeHistoryReader;
+  readonly candlesticks: CandlesticksReader;
+  readonly userSubaccounts: UserSubaccountsReader;
+  readonly userPositions: UserPositionsReader;
+  readonly userOrderHistory: UserOrderHistoryReader;
+  readonly userOpenOrders: UserOpenOrdersReader;
+  readonly userBulkOrders: UserBulkOrdersReader;
+  readonly userActiveTwaps: UserActiveTwapsReader;
+  readonly portfolioChart: PortfolioChartReader;
+  readonly leaderboard: LeaderboardReader;
+  readonly vaults: VaultsReader;
+  readonly delegations: DelegationsReader;
+  readonly userNotifications: UserNotificationsReader;
+
+  constructor(
+    readonly config: DecibelConfig,
+    opts?: {
+      nodeApiKey?: string;
+      onWsError?: (error: ErrorEvent) => void;
+    },
+  ) {
+    const aptosConfig = new AptosConfig({
+      network: config.network,
+      fullnode: config.fullnodeUrl,
+      clientConfig: { API_KEY: opts?.nodeApiKey },
+    });
+
+    this.deps = {
+      aptos: new Aptos(aptosConfig),
+      ws: new DecibelWsSubscription(config, opts?.onWsError),
+      config: this.config,
+      apiKey: opts?.nodeApiKey,
+    };
+
+    this.cache = {};
+    this.accountOverview = new AccountOverviewReader(this.deps);
+    this.markets = new MarketsReader(this.deps);
+    this.marketContexts = new MarketContextsReader(this.deps);
+    this.marketDepth = new MarketDepthReader(this.deps);
+    this.marketPrices = new MarketPricesReader(this.deps);
+    this.marketTrades = new MarketTradesReader(this.deps);
+    this.userPositions = new UserPositionsReader(this.deps);
+    this.userOrderHistory = new UserOrderHistoryReader(this.deps);
+    this.userSubaccounts = new UserSubaccountsReader(this.deps);
+    this.userOpenOrders = new UserOpenOrdersReader(this.deps);
+    this.userBulkOrders = new UserBulkOrdersReader(this.deps);
+    this.userFundingHistory = new UserFundingHistoryReader(this.deps);
+    this.userTradeHistory = new UserTradeHistoryReader(this.deps);
+    this.userActiveTwaps = new UserActiveTwapsReader(this.deps);
+    this.candlesticks = new CandlesticksReader(this.deps);
+    this.portfolioChart = new PortfolioChartReader(this.deps);
+    this.leaderboard = new LeaderboardReader(this.deps);
+    this.vaults = new VaultsReader(this.deps);
+    this.delegations = new DelegationsReader(this.deps);
+    this.userNotifications = new UserNotificationsReader(this.deps);
+  }
+
+  async globalPerpEngineState() {
+    try {
+      // Attempt to get the global perp engine state resource
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return, custom/no-get-account-resource
+      return await this.deps.aptos.getAccountResource({
+        accountAddress: this.config.deployment.package,
+        resourceType: `${this.config.deployment.package}::perp_engine::Global`,
+      });
+    } catch {
+      return false;
+    }
+  }
+
+  async collateralBalanceDecimals() {
+    const decimals = await this.deps.aptos.view<[string]>({
+      payload: {
+        function: `${this.config.deployment.package}::perp_engine::collateral_balance_decimals`,
+        typeArguments: [],
+        functionArguments: [],
+      },
+    });
+    return Number(decimals[0]);
+  }
+
+  async usdcDecimals() {
+    if (this.cache.usdcDecimals) {
+      return this.cache.usdcDecimals;
+    }
+    const decimals = await this.deps.aptos.view<[string]>({
+      payload: {
+        function: `0x1::fungible_asset::decimals`,
+        typeArguments: ["0x1::fungible_asset::Metadata"],
+        functionArguments: [this.config.deployment.usdc],
+      },
+    });
+    this.cache.usdcDecimals = Number(decimals[0]);
+    return this.cache.usdcDecimals;
+  }
+
+  async usdcBalance(addr: string | AccountAddress) {
+    const usdcDecimals = await this.usdcDecimals();
+    const balance = await this.deps.aptos.view<[string]>({
+      payload: {
+        function: `0x1::primary_fungible_store::balance`,
+        typeArguments: ["0x1::fungible_asset::Metadata"],
+        functionArguments: [addr, this.config.deployment.usdc],
+      },
+    });
+    return Number(balance[0]) / 10 ** usdcDecimals;
+  }
+
+  /**
+   * Get the number of restricted mints remaining for the day.
+   * Global value. Not specific to an account.
+   *
+   * @remarks This method is temporary and only for use in testnet. The mints_remaining
+   * view function is a testnet-only feature and should be removed before mainnet deployment.
+   */
+  async mintsRemaining(): Promise<number> {
+    const result = await this.deps.aptos.view<[string]>({
+      payload: {
+        function: `${this.config.deployment.package}::usdc::mints_remaining`,
+        typeArguments: [],
+        functionArguments: [],
+      },
+    });
+    return Number(result[0]);
+  }
+
+  /**
+   * Get the available restricted mint amount for an account (account limit).
+   * Returns the amount in chain units (raw u64).
+   *
+   * @remarks This method is temporary and only for use in testnet. The available_restricted_mint_for
+   * view function is a testnet-only feature and should be removed before mainnet deployment.
+   */
+  async availableRestrictedMintFor(addr: string | AccountAddress): Promise<number> {
+    const result = await this.deps.aptos.view<[string]>({
+      payload: {
+        function: `${this.config.deployment.package}::usdc::available_restricted_mint_for`,
+        typeArguments: [],
+        functionArguments: [addr],
+      },
+    });
+    return Number(result[0]);
+  }
+
+  /**
+   * Get the timestamp when the restricted mint limits reset (in seconds).
+   *
+   * @remarks This method is temporary and only for use in testnet. The restricted_mint_daily_reset_timestamp
+   * view function is a testnet-only feature and should be removed before mainnet deployment.
+   */
+  async getTriggerResetMintTs(): Promise<number> {
+    const result = await this.deps.aptos.view<[string]>({
+      payload: {
+        function: `${this.config.deployment.package}::usdc::restricted_mint_daily_reset_timestamp`,
+        typeArguments: [],
+        functionArguments: [],
+      },
+    });
+    return Number(result[0]);
+  }
+
+  async tokenBalance(
+    addr: string | AccountAddress,
+    tokenAddr: string | AccountAddress,
+    tokenDecimals: number,
+  ) {
+    const balance = await this.deps.aptos.view<[string]>({
+      payload: {
+        function: `0x1::primary_fungible_store::balance`,
+        typeArguments: ["0x1::fungible_asset::Metadata"],
+        functionArguments: [addr, tokenAddr],
+      },
+    });
+    return Number(balance[0]) / 10 ** tokenDecimals;
+  }
+
+  /**
+   * Get the balance of the account
+   * @returns The balance of the account
+   */
+  async accountBalance(addr: AccountAddress) {
+    const balance = await this.deps.aptos.view<[number]>({
+      payload: {
+        function: `${this.config.deployment.package}::perp_engine::get_account_balance_fungible`,
+        typeArguments: [],
+        functionArguments: [addr],
+      },
+    });
+    return balance[0];
+  }
+
+  /**
+   * Get the size of the position for an account
+   * @param addr The address of the account to get the position size for
+   * @param marketAddr The name of the market to get the position size for
+   * @returns The size of the position for the account
+   */
+  async positionSize(addr: AccountAddress, marketAddr: string) {
+    return await this.deps.aptos.view<[number]>({
+      payload: {
+        function: `${this.config.deployment.package}::perp_engine::get_position_size`,
+        typeArguments: [],
+        functionArguments: [addr, marketAddr],
+      },
+    });
+  }
+
+  /**
+   * Get the crossed position for an account
+   * @param addr The address of the account to get the crossed position for
+   * @returns The crossed position for the account
+   */
+  async getCrossedPosition(addr: AccountAddress) {
+    const seed = new TextEncoder().encode("perp_position");
+    const crossedPositionAddr = createObjectAddress(addr, seed);
+    try {
+      // TODO: Fix lint error
+      // eslint-disable-next-line custom/no-get-account-resource
+      const crossedPosition = await this.deps.aptos.getAccountResource<CrossedPosition>({
+        accountAddress: crossedPositionAddr,
+        resourceType: `${this.config.deployment.package}::perp_positions::CrossedPosition`,
+      });
+      return CrossedPosition.parse(crossedPosition);
+    } catch {
+      return null;
+    }
+  }
+}

package/src/read/leaderboard/leaderboard.reader.ts

@@ -0,0 +1,21 @@
+import { constructKnownQueryParams } from "../../utils";
+import { BaseReader } from "../base-reader";
+import { LeaderboardRequestArgs, LeaderboardSchema } from "./leaderboard.types";
+
+export class LeaderboardReader extends BaseReader {
+  /**
+   * Get the leaderboard
+   * @param queryParams The query parameters for the leaderboard
+   * @returns The leaderboard
+   */
+  async getLeaderboard({ fetchOptions, ...args }: LeaderboardRequestArgs) {
+    const response = await this.getRequest({
+      schema: LeaderboardSchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/leaderboard`,
+      queryParams: constructKnownQueryParams(args),
+      options: fetchOptions,
+    });
+
+    return response.data;
+  }
+}

package/src/read/leaderboard/leaderboard.types.ts

@@ -0,0 +1,26 @@
+import { z } from "zod/v4";
+
+import { BaseRequestArgs } from "../base-reader";
+import { PageParams, PaginatedResponseSchema, SearchTermParams, SortParams } from "../types";
+
+export type LeaderboardSortKey = "volume" | "realized_pnl" | "roi" | "account_value";
+
+export interface LeaderboardRequestArgs
+  extends BaseRequestArgs,
+    PageParams,
+    SearchTermParams,
+    SortParams<LeaderboardSortKey> {}
+
+export const LeaderboardItemSchema = z.object({
+  rank: z.number(),
+  account: z.string(),
+  account_value: z.number(),
+  realized_pnl: z.number(),
+  roi: z.number(),
+  volume: z.number(),
+});
+
+export const LeaderboardSchema = PaginatedResponseSchema(LeaderboardItemSchema);
+
+export type LeaderboardItem = z.infer<typeof LeaderboardItemSchema>;
+export type Leaderboard = z.infer<typeof LeaderboardSchema>;

package/src/read/market-contexts/market-contexts.reader.ts

@@ -0,0 +1,26 @@
+import { BaseReader, BaseRequestArgs } from "../base-reader";
+import { MarketContextsSchema } from "./market-contexts.types";
+
+export class MarketContextsReader extends BaseReader {
+  /**
+   * Get the asset context for a given market
+   *
+   * // DEV NOTE: marketName is not supported by the API yet
+   * // @param marketName The name of the market to get asset context for
+   * @returns The asset context for the given market or all if no market name is provided
+   */
+  async getAll({ fetchOptions }: BaseRequestArgs = {}) {
+    // const marketAddr = marketName
+    //   ? getMarketAddr(marketName, this.config.deployment.perpEngineGlobal)
+    //   : undefined;
+    const response = await this.getRequest({
+      schema: MarketContextsSchema,
+      // TODO: Update this when the API is /market_contexts
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/asset_contexts`,
+      // queryParams: marketAddr ? { market: marketAddr.toString() } : undefined,
+      options: fetchOptions,
+    });
+
+    return response.data;
+  }
+}

package/src/read/market-contexts/market-contexts.types.ts

@@ -0,0 +1,18 @@
+import z from "zod/v4";
+
+export const MarketContextSchema = z.object({
+  market: z.string(),
+  volume_24h: z.number(),
+  open_interest: z.number(),
+  mark_price: z.number(),
+  mid_price: z.number(),
+  oracle_price: z.number(),
+  previous_day_price: z.number(),
+  price_change_pct_24h: z.number(),
+  price_history: z.array(z.number()),
+});
+
+export const MarketContextsSchema = z.array(MarketContextSchema);
+
+export type MarketContext = z.infer<typeof MarketContextSchema>;
+export type MarketContexts = z.infer<typeof MarketContextsSchema>;

package/src/read/market-depth/market-depth.reader.ts

@@ -0,0 +1,60 @@
+import { getMarketAddr } from "../../utils";
+import { BaseReader } from "../base-reader";
+import {
+  MarketDepth,
+  MarketDepthAggregationSize,
+  MarketDepthRequestArgs,
+  MarketDepthSchema,
+} from "./market-depth.types";
+
+export class MarketDepthReader extends BaseReader {
+  /**
+   * Get the market depth data for a given market
+   * @param marketName The name of the market to get market depth for
+   * @returns The market depth data for the given market
+   */
+  async getByName({ marketName, limit, fetchOptions }: MarketDepthRequestArgs) {
+    const marketAddr = getMarketAddr(marketName, this.deps.config.deployment.perpEngineGlobal);
+    const queryParams = new URLSearchParams({ market: marketAddr.toString() });
+    if (limit !== undefined) {
+      queryParams.set("limit", limit.toString());
+    }
+
+    const response = await this.getRequest({
+      schema: MarketDepthSchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/depth`,
+      queryParams,
+      options: fetchOptions,
+    });
+
+    return response.data;
+  }
+
+  /**
+   * Subscribe to market depth updates for a given market ID
+   * @param marketName The name of the market to subscribe to
+   * @param onData Callback function for received market depth data
+   * @returns A function to unsubscribe from the market depth updates
+   */
+  subscribeByName(
+    marketName: string,
+    aggregationSize: MarketDepthAggregationSize,
+    onData: (data: MarketDepth) => void,
+  ) {
+    const marketAddr = getMarketAddr(marketName, this.deps.config.deployment.perpEngineGlobal);
+    const topic = `depth:${marketAddr}:${aggregationSize}`;
+
+    return this.deps.ws.subscribe(topic, MarketDepthSchema, onData);
+  }
+
+  resetSubscriptionByName(marketName: string, aggregationSize: MarketDepthAggregationSize = 1) {
+    const marketAddr = getMarketAddr(marketName, this.deps.config.deployment.perpEngineGlobal);
+    const topic = `depth:${marketAddr}:${aggregationSize}`;
+
+    this.deps.ws.reset(topic);
+  }
+
+  getAggregationSizes() {
+    return [1, 2, 5, 10] as const satisfies MarketDepthAggregationSize[];
+  }
+}

package/src/read/market-depth/market-depth.types.ts

@@ -0,0 +1,24 @@
+import z from "zod/v4";
+
+import { BaseRequestArgs } from "../base-reader";
+
+export interface MarketDepthRequestArgs extends BaseRequestArgs {
+  marketName: string;
+  limit?: number;
+}
+
+export const MarketOrderSchema = z.object({
+  price: z.number(),
+  size: z.number(),
+});
+
+export const MarketDepthSchema = z.object({
+  market: z.string(),
+  bids: z.array(MarketOrderSchema),
+  asks: z.array(MarketOrderSchema),
+});
+
+// TODO: These values will change in the near future
+export type MarketDepthAggregationSize = 1 | 2 | 5 | 10;
+export type MarketOrder = z.infer<typeof MarketOrderSchema>;
+export type MarketDepth = z.infer<typeof MarketDepthSchema>;

package/src/read/market-prices/market-prices.reader.ts

@@ -0,0 +1,61 @@
+import { getMarketAddr } from "../../utils";
+import { BaseReader, BaseRequestArgs } from "../base-reader";
+import {
+  MarketPricesByNameRequestArgs,
+  MarketPricesSchema,
+  MarketPriceWsMessage,
+  MarketPriceWsMessageSchema,
+} from "./market-prices.types";
+
+export class MarketPricesReader extends BaseReader {
+  async getAll({ fetchOptions }: BaseRequestArgs = {}) {
+    const response = await this.getRequest({
+      schema: MarketPricesSchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/prices`,
+      options: fetchOptions,
+    });
+    return response.data;
+  }
+
+  /**
+   * Get the price data for a given market
+   * @param marketName The name of the market to get prices for
+   * @returns The price data for the given market
+   */
+  async getByName({ marketName, fetchOptions }: MarketPricesByNameRequestArgs) {
+    const marketAddr = getMarketAddr(marketName, this.deps.config.deployment.perpEngineGlobal);
+
+    const response = await this.getRequest({
+      schema: MarketPricesSchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/prices`,
+      queryParams: { market: marketAddr.toString() },
+      options: fetchOptions,
+    });
+    return response.data;
+  }
+
+  /**
+   * Subscribe to price updates for a market
+   * @param marketName The name of the market to subscribe to
+   * @param onData Callback function for received price data
+   * @returns A function to unsubscribe from the oracle price updates
+   */
+  subscribeByName(marketName: string, onData: (data: MarketPriceWsMessage) => void) {
+    const marketAddr = getMarketAddr(marketName, this.deps.config.deployment.perpEngineGlobal);
+    const topic = `market_price:${marketAddr}`;
+
+    return this.deps.ws.subscribe(topic, MarketPriceWsMessageSchema, onData);
+  }
+
+  /**
+   * Subscribe to price updates for a market
+   * @param marketAddr The address of the market to subscribe to
+   * @param onData Callback function for received price data
+   * @returns A function to unsubscribe from the oracle price updates
+   */
+  subscribeByAddress(marketAddr: string, onData: (data: MarketPriceWsMessage) => void) {
+    const topic = `market_price:${marketAddr}`;
+
+    return this.deps.ws.subscribe(topic, MarketPriceWsMessageSchema, onData);
+  }
+}

package/src/read/market-prices/market-prices.types.ts

@@ -0,0 +1,38 @@
+import { z } from "zod/v4";
+
+import { BaseRequestArgs } from "../base-reader";
+
+export interface MarketPricesByNameRequestArgs extends BaseRequestArgs {
+  marketName: string;
+}
+
+export const PricesSchema = z.object({
+  market: z.string(),
+  mark_px: z.number(),
+  mid_px: z.number(),
+  oracle_px: z.number(),
+  funding_rate_bps: z.number(),
+  is_funding_positive: z.boolean(),
+  open_interest: z.number(),
+  transaction_unix_ms: z.number(),
+});
+
+export const MarketPricesSchema = z.array(PricesSchema);
+
+export const MarketPriceSchema = z.object({
+  market: z.string(),
+  mark_px: z.number(),
+  mid_px: z.number(),
+  oracle_px: z.number(),
+  funding_rate_bps: z.number(),
+  is_funding_positive: z.boolean(),
+  open_interest: z.number(),
+  transaction_unix_ms: z.number(),
+});
+
+export const MarketPriceWsMessageSchema = z.object({ price: MarketPriceSchema });
+
+export type Prices = z.infer<typeof PricesSchema>;
+export type MarketPrices = z.infer<typeof MarketPricesSchema>;
+export type MarketPrice = z.infer<typeof MarketPriceSchema>;
+export type MarketPriceWsMessage = z.infer<typeof MarketPriceWsMessageSchema>;

package/src/read/market-trades/market-trades.reader.ts

@@ -0,0 +1,46 @@
+import { getMarketAddr } from "../../utils";
+import { BaseReader } from "../base-reader";
+import {
+  MarketTradesHistorySchema,
+  MarketTradesRequestArgs,
+  MarketTradeWsMessage,
+  MarketTradeWsMessageSchema,
+} from "./market-trades.types";
+
+export class MarketTradesReader extends BaseReader {
+  /**
+   * Get the latest market trades for a given market
+   * @param marketName The name of the market to get market trades for
+   * @param limit The number of market trades to get
+   * @returns The market trades for the given market
+   */
+  async getByName({ marketName, limit, fetchOptions }: MarketTradesRequestArgs) {
+    const marketAddr = getMarketAddr(marketName, this.deps.config.deployment.perpEngineGlobal);
+    const queryParams = new URLSearchParams({ market: marketAddr.toString() });
+    if (limit !== undefined) {
+      queryParams.set("limit", limit.toString());
+    }
+
+    const response = await this.getRequest({
+      schema: MarketTradesHistorySchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/trades`,
+      queryParams,
+      options: fetchOptions,
+    });
+
+    return response.data;
+  }
+
+  /**
+   * Subscribe to the latest market trades for a given market
+   * @param marketName The name of the market to subscribe to
+   * @param onData Callback function for received market trades data
+   * @returns A function to unsubscribe from the market trades updates
+   */
+  subscribeByName(marketName: string, onData: (data: MarketTradeWsMessage) => void) {
+    const marketAddr = getMarketAddr(marketName, this.deps.config.deployment.perpEngineGlobal);
+    const topic = `trades:${marketAddr}`;
+
+    return this.deps.ws.subscribe(topic, MarketTradeWsMessageSchema, onData);
+  }
+}

package/src/read/market-trades/market-trades.types.ts

@@ -0,0 +1,34 @@
+import { z } from "zod/v4";
+
+import { BaseRequestArgs } from "../base-reader";
+
+export interface MarketTradesRequestArgs extends BaseRequestArgs {
+  marketName: string;
+  limit?: number;
+}
+
+export const MarketTradeSchema = z.object({
+  account: z.string(),
+  market: z.string(),
+  action: z.string(),
+  size: z.number(),
+  price: z.number(),
+  is_profit: z.boolean(),
+  realized_pnl_amount: z.number(),
+  is_funding_positive: z.boolean(),
+  realized_funding_amount: z.number(),
+  is_rebate: z.boolean(),
+  fee_amount: z.number(),
+  transaction_unix_ms: z.number(),
+  transaction_version: z.number(),
+});
+
+export const MarketTradesHistorySchema = z.array(MarketTradeSchema);
+
+export const MarketTradeWsMessageSchema = z.object({
+  trades: z.array(MarketTradeSchema),
+});
+
+export type MarketTrade = z.infer<typeof MarketTradeSchema>;
+export type MarketTradesHistory = z.infer<typeof MarketTradesHistorySchema>;
+export type MarketTradeWsMessage = z.infer<typeof MarketTradeWsMessageSchema>;