@decibeltrade/sdk 0.1.1

package/src/read/markets/markets.reader.ts

@@ -0,0 +1,82 @@
+import { getMarketAddr } from "../../utils";
+import { BaseReader, BaseRequestArgs } from "../base-reader";
+import { PerpMarketConfig, PerpMarketConfigSchema, PerpMarketsSchema } from "./markets.types";
+
+export class MarketsReader extends BaseReader {
+  /**
+   * Get all of the available markets
+   * @returns The list of available markets
+   */
+  async getAll({ fetchOptions }: BaseRequestArgs = {}) {
+    const response = await this.getRequest({
+      schema: PerpMarketsSchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/markets`,
+      options: fetchOptions,
+    });
+
+    // TODO: Remove once API is fixed and doesn't return duplicate markets
+    const seen = new Set<string>();
+    const uniqueMarkets = response.data.filter((market) => {
+      if (seen.has(market.market_addr)) {
+        return false;
+      }
+      seen.add(market.market_addr);
+      return true;
+    });
+
+    return uniqueMarkets;
+  }
+
+  /**
+   * Get the market config for a given market name
+   * @param marketName The name of the market to get
+   * @returns The market config for the given name
+   */
+  async getByName(marketName: string): Promise<PerpMarketConfig | null> {
+    const marketAddr = getMarketAddr(marketName, this.deps.config.deployment.perpEngineGlobal);
+    try {
+      // TODO: Fix lint error
+      // eslint-disable-next-line custom/no-get-account-resource
+      const market = await this.deps.aptos.getAccountResource<PerpMarketConfig>({
+        accountAddress: marketAddr,
+        resourceType: `${this.deps.config.deployment.package}::perp_market_config::PerpMarketConfig`,
+      });
+      // TODO: Handle different __variant__ values
+      return PerpMarketConfigSchema.parse(market);
+    } catch (e) {
+      console.error(e);
+      return null;
+    }
+  }
+
+  /**
+   * List all of the market addresses
+   * @returns The list of market addresses
+   */
+  async listMarketAddresses() {
+    const markets = await this.deps.aptos.view<[string[]]>({
+      payload: {
+        function: `${this.deps.config.deployment.package}::perp_engine::list_markets`,
+        typeArguments: [],
+        functionArguments: [],
+      },
+    });
+    return markets[0];
+  }
+
+  /**
+   * Get the name of a market by address
+   * @param marketAddr The address of the market
+   * @returns The name of the market
+   */
+  async marketNameByAddress(marketAddr: string) {
+    const name = await this.deps.aptos.view<[string]>({
+      payload: {
+        function: `${this.deps.config.deployment.package}::perp_engine::market_name`,
+        typeArguments: [],
+        functionArguments: [marketAddr],
+      },
+    });
+    return name[0];
+  }
+}

package/src/read/markets/markets.types.ts

@@ -0,0 +1,54 @@
+import { z } from "zod/v4";
+
+export const MarketModeConfigSchema = z.discriminatedUnion("__variant__", [
+  z.object({ __variant__: z.literal("Open") }),
+  z.object({ __variant__: z.literal("ReduceOnly") }),
+  z.object({
+    __variant__: z.literal("AllowlistOnly"),
+    allowlist: z.array(z.string()),
+  }),
+  z.object({ __variant__: z.literal("Halt") }),
+]);
+
+export const PerpMarketConfigSchema = z.object({
+  __variant__: z.literal("V1"),
+  name: z.string(),
+  sz_precision: z.object({
+    decimals: z.number(),
+    multiplier: z.string(),
+  }),
+  min_size: z.string(),
+  lot_size: z.string(),
+  ticker_size: z.string(),
+  max_leverage: z.number(),
+  mode: MarketModeConfigSchema,
+});
+
+export const MarketModeSchema = z.enum([
+  "Open",
+  "ReduceOnly",
+  "AllowlistOnly",
+  "Halt",
+  "Delisting",
+]);
+
+export const PerpMarketSchema = z.object({
+  market_addr: z.string(),
+  market_name: z.string(),
+  sz_decimals: z.number(),
+  px_decimals: z.number(),
+  max_leverage: z.number(),
+  tick_size: z.number(),
+  min_size: z.number(),
+  lot_size: z.number(),
+  max_open_interest: z.number(),
+  mode: MarketModeSchema,
+});
+
+export const PerpMarketsSchema = z.array(PerpMarketSchema);
+
+export type MarketModeConfig = z.infer<typeof MarketModeConfigSchema>;
+export type PerpMarketConfig = z.infer<typeof PerpMarketConfigSchema>;
+export type MarketMode = z.infer<typeof MarketModeSchema>;
+export type PerpMarket = z.infer<typeof PerpMarketSchema>;
+export type PerpMarkets = z.infer<typeof PerpMarketsSchema>;

package/src/read/pagination.types.ts

@@ -0,0 +1,18 @@
+import z from "zod/v4";
+
+export const PaginatedResponseSchema = <T extends z.ZodType>(itemSchema: T) =>
+  z.object({
+    items: z.array(itemSchema),
+    total_count: z.number(),
+  });
+
+export interface PaginatedResponse<T> {
+  items: T[];
+  total_count: number;
+}
+
+// Page related types
+export interface PageParams {
+  limit?: number;
+  offset?: number;
+}

package/src/read/portfolio-chart/portfolio-chart.reader.ts

@@ -0,0 +1,20 @@
+import { BaseReader } from "../base-reader";
+import { PortfolioChartRequestArgs, PortfolioChartSchema } from "./portfolio-chart.types";
+
+export class PortfolioChartReader extends BaseReader {
+  /**
+   * Get the portfolio chart for a given user
+   * @param subAddr The subaccount address to get the account overview for
+   * @returns The account overview for the given subaccount address
+   */
+  async getByAddr({ subAddr, range, type, fetchOptions }: PortfolioChartRequestArgs) {
+    const response = await this.getRequest({
+      schema: PortfolioChartSchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/portfolio_chart`,
+      queryParams: { user: subAddr, range, data_type: type },
+      options: fetchOptions,
+    });
+
+    return response.data;
+  }
+}

package/src/read/portfolio-chart/portfolio-chart.types.ts

@@ -0,0 +1,21 @@
+import z from "zod/v4";
+
+import { BaseRequestArgs } from "../base-reader";
+
+export interface PortfolioChartRequestArgs extends BaseRequestArgs {
+  subAddr: string;
+  range: PortfolioChartTimeRange;
+  type: PortfolioChartType;
+}
+
+export const PortfolioChartPnlItemSchema = z.object({
+  timestamp: z.number(),
+  data_points: z.number(),
+});
+
+export const PortfolioChartSchema = z.array(PortfolioChartPnlItemSchema);
+
+export type PortfolioChartType = "pnl" | "account_value";
+export type PortfolioChartTimeRange = "24h" | "7d" | "30d" | "90d";
+export type PortfolioChartItem = z.infer<typeof PortfolioChartPnlItemSchema>;
+export type PortfolioChart = z.infer<typeof PortfolioChartSchema>;

package/src/read/types.ts

@@ -0,0 +1,129 @@
+import { z } from "zod/v4";
+
+// Export all types from readers
+export * from "./account-overview/account-overview.types";
+export * from "./candlesticks/candlesticks.types";
+export * from "./delegations/delegations.types";
+export * from "./leaderboard/leaderboard.types";
+export * from "./market-contexts/market-contexts.types";
+export * from "./market-depth/market-depth.types";
+export * from "./market-prices/market-prices.types";
+export * from "./market-trades/market-trades.types";
+export * from "./markets/markets.types";
+export * from "./pagination.types";
+export * from "./portfolio-chart/portfolio-chart.types";
+export * from "./user-active-twaps/user-active-twaps.types";
+export * from "./user-bulk-orders/user-bulk-orders.types";
+export * from "./user-funding-history/user-funding-history.types";
+export * from "./user-notifications/user-notifications.types";
+export * from "./user-open-orders/user-open-orders.types";
+export * from "./user-order-history/user-order-history.types";
+export * from "./user-positions/user-positions.types";
+export * from "./user-subaccounts/user-subaccounts.types";
+export * from "./user-trade-history/user-trade-history.types";
+export * from "./vaults/vaults.types";
+
+export const PerpPosition = z.object({
+  size: z.number(),
+  sz_decimals: z.number(),
+  entry_px: z.number(),
+  max_leverage: z.number(),
+  is_long: z.boolean(),
+  token_type: z.string(),
+});
+export type PerpPosition = z.infer<typeof PerpPosition>;
+
+export const CrossedPosition = z.object({
+  positions: z.array(PerpPosition),
+});
+export type CrossedPosition = z.infer<typeof CrossedPosition>;
+
+export const LiquidationConfigV1 = z.object({
+  __variant__: z.literal("V1"),
+  backstop_liquidator: z.string(),
+  backstop_margin_maintenance_divisor: z.string(),
+  backstop_margin_maintenance_multiplier: z.string(),
+  maintenance_margin_leverage_divisor: z.string(),
+  maintenance_margin_leverage_multiplier: z.string(),
+});
+export type LiquidationConfigV1 = z.infer<typeof LiquidationConfigV1>;
+
+export const CollateralBalanceSheet = z.object({
+  asset_type: z.object({
+    inner: z.string(),
+  }),
+  asset_precision: z.object({
+    decimals: z.number(),
+    multiplier: z.string(),
+  }),
+  balance_precision: z.object({
+    decimals: z.number(),
+    multiplier: z.string(),
+  }),
+  balance_table: z.object({
+    handle: z.string(),
+  }),
+  store: z.object({
+    inner: z.string(),
+  }),
+  store_extend_ref: z.object({
+    self: z.string(),
+  }),
+});
+export type CollateralBalanceSheet = z.infer<typeof CollateralBalanceSheet>;
+
+export const GlobalAccountsStateV1 = z.object({
+  __variant__: z.string(),
+  collateral: CollateralBalanceSheet,
+  liquidation_config: LiquidationConfigV1,
+});
+export type GlobalAccountsStateV1 = z.infer<typeof GlobalAccountsStateV1>;
+
+export const GlobalAccountsState = GlobalAccountsStateV1;
+export type GlobalAccountsState = z.infer<typeof GlobalAccountsState>;
+
+// Search term
+export interface SearchTermParams {
+  searchTerm?: string;
+}
+
+// Sort direction
+export type SortDirection = "ASC" | "DESC" | undefined;
+
+// Sort params
+export interface SortParams<T extends string> {
+  sortKey?: T;
+  sortDir?: SortDirection;
+}
+
+// Vaults
+export interface CreateVaultArgs {
+  contributionAssetType?: string;
+  vaultName: string;
+  vaultDescription: string;
+  vaultSocialLinks: string[];
+  vaultShareSymbol: string;
+  vaultShareIconUri?: string;
+  vaultShareProjectUri?: string;
+  feeBps: number;
+  feeIntervalS: number;
+  contributionLockupDurationS: number;
+  initialFunding: number;
+  acceptsContributions: boolean;
+  delegateToCreator: boolean;
+}
+
+export interface ActivateVaultArgs {
+  vaultAddress: string;
+  additionalFunding?: number;
+}
+
+export interface DepositToVaultArgs {
+  vaultAddress: string;
+  amount: number;
+}
+
+export interface WithdrawFromVaultArgs {
+  vaultAddress: string;
+  shares: number;
+}

package/src/read/user-active-twaps/user-active-twaps.reader.ts

@@ -0,0 +1,36 @@
+import { BaseReader } from "../base-reader";
+import {
+  UserActiveTwapsRequestArgs,
+  UserActiveTwapsSchema,
+  UserActiveTwapsWsMessage,
+  UserActiveTwapsWsMessageSchema,
+} from "./user-active-twaps.types";
+
+export class UserActiveTwapsReader extends BaseReader {
+  /**
+   * Get the active twaps for a given user
+   * @param subAddr The subaccount address of the user to get active twaps for
+   * @returns The active twaps for the given user
+   */
+  async getByAddr({ subAddr, fetchOptions }: UserActiveTwapsRequestArgs) {
+    const response = await this.getRequest({
+      schema: UserActiveTwapsSchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/active_twaps`,
+      queryParams: { user: subAddr },
+      options: fetchOptions,
+    });
+
+    return response.data;
+  }
+
+  /**
+   * Subscribe to active twaps updates
+   * @param subAddr The subaccount address of the user to subscribe to
+   * @param onData Callback function for received active twaps data
+   * @returns A function to unsubscribe from the active twaps updates
+   */
+  subscribeByAddr(subAddr: string, onData: (data: UserActiveTwapsWsMessage) => void) {
+    const topic = `user_active_twaps:${subAddr}`;
+    return this.deps.ws.subscribe(topic, UserActiveTwapsWsMessageSchema, onData);
+  }
+}

package/src/read/user-active-twaps/user-active-twaps.types.ts

@@ -0,0 +1,33 @@
+import z from "zod/v4";
+
+import { BaseRequestArgs } from "../base-reader";
+
+export interface UserActiveTwapsRequestArgs extends BaseRequestArgs {
+  subAddr: string;
+}
+
+export const UserActiveTwapSchema = z.object({
+  market: z.string(),
+  is_buy: z.boolean(),
+  order_id: z.string(),
+  client_order_id: z.string().nullable().optional(),
+  is_reduce_only: z.boolean(),
+  start_unix_ms: z.number(),
+  frequency_s: z.number(),
+  duration_s: z.number(),
+  orig_size: z.number(),
+  remaining_size: z.number(),
+  status: z.string(),
+  transaction_unix_ms: z.number(),
+  transaction_version: z.number(),
+});
+
+export const UserActiveTwapsSchema = z.array(UserActiveTwapSchema);
+
+export const UserActiveTwapsWsMessageSchema = z.object({
+  twaps: z.array(UserActiveTwapSchema),
+});
+
+export type UserActiveTwap = z.infer<typeof UserActiveTwapSchema>;
+export type UserActiveTwaps = z.infer<typeof UserActiveTwapsSchema>;
+export type UserActiveTwapsWsMessage = z.infer<typeof UserActiveTwapsWsMessageSchema>;

package/src/read/user-bulk-orders/user-bulk-orders.reader.ts

@@ -0,0 +1,37 @@
+import { BaseReader } from "../base-reader";
+import {
+  UserBulkOrdersRequestArgs,
+  UserBulkOrdersSchema,
+  UserBulkOrdersWsMessage,
+  UserBulkOrdersWsMessageSchema,
+} from "./user-bulk-orders.types";
+
+export class UserBulkOrdersReader extends BaseReader {
+  /**
+   * Get the bulk orders for a given user
+   * @param subAddr The subaccount address of the user to get bulk orders for
+   * @param market Optional market address to filter by specific market
+   * @returns The bulk orders for the given user
+   */
+  async getByAddr({ subAddr, market, fetchOptions }: UserBulkOrdersRequestArgs) {
+    const response = await this.getRequest({
+      schema: UserBulkOrdersSchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/bulk_orders`,
+      queryParams: { user: subAddr, market: market || "all" },
+      options: fetchOptions,
+    });
+
+    return response.data;
+  }
+
+  /**
+   * Subscribe to user bulk orders updates
+   * @param subAddr The subaccount address of the user to subscribe to
+   * @param onData Callback function for received user bulk orders data
+   * @returns A function to unsubscribe from the user bulk orders updates
+   */
+  subscribeByAddr(subAddr: string, onData: (data: UserBulkOrdersWsMessage) => void) {
+    const topic = `bulk_orders:${subAddr}`;
+    return this.deps.ws.subscribe(topic, UserBulkOrdersWsMessageSchema, onData);
+  }
+}

package/src/read/user-bulk-orders/user-bulk-orders.types.ts

@@ -0,0 +1,32 @@
+import z from "zod/v4";
+
+import { BaseRequestArgs } from "../base-reader";
+
+export interface UserBulkOrdersRequestArgs extends BaseRequestArgs {
+  subAddr: string;
+  market?: string;
+}
+
+export const UserBulkOrderSchema = z.object({
+  market: z.string(),
+  sequence_number: z.number(),
+  previous_seq_num: z.number(),
+  bid_prices: z.array(z.number()),
+  bid_sizes: z.array(z.number()),
+  ask_prices: z.array(z.number()),
+  ask_sizes: z.array(z.number()),
+  cancelled_bid_prices: z.array(z.number()),
+  cancelled_bid_sizes: z.array(z.number()),
+  cancelled_ask_prices: z.array(z.number()),
+  cancelled_ask_sizes: z.array(z.number()),
+});
+
+export const UserBulkOrdersSchema = z.array(UserBulkOrderSchema);
+
+export const UserBulkOrdersWsMessageSchema = z.object({
+  bulk_orders: z.array(UserBulkOrderSchema),
+});
+
+export type UserBulkOrder = z.infer<typeof UserBulkOrderSchema>;
+export type UserBulkOrders = z.infer<typeof UserBulkOrdersSchema>;
+export type UserBulkOrdersWsMessage = z.infer<typeof UserBulkOrdersWsMessageSchema>;

package/src/read/user-funding-history/user-funding-history.reader.ts

@@ -0,0 +1,38 @@
+import { BaseReader } from "../base-reader";
+import {
+  UserFundingHistoryRequestArgs,
+  UserFundingHistorySchema,
+  UserFundingHistoryWsMessage,
+  UserFundingHistoryWsMessageSchema,
+} from "./user-funding-history.types";
+
+export class UserFundingHistoryReader extends BaseReader {
+  /**
+   * Get the trade history for a given user
+   * @param subAddr The subaccount address of the user to get trade history for
+   * @param limit The number of trades to get (default: 10)
+   * @returns The trade history for the given user
+   */
+  async getByAddr({ subAddr, limit = 10, fetchOptions }: UserFundingHistoryRequestArgs) {
+    const response = await this.getRequest({
+      schema: UserFundingHistorySchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/funding_rate_history`,
+      queryParams: { user: subAddr, limit: limit.toString() },
+      options: fetchOptions,
+    });
+
+    return response.data;
+  }
+
+  /**
+   * Subscribe to trade history updates
+   * @param subAddr The subaccount address of the user to subscribe to
+   * @param onData Callback function for received trade history data
+   * @returns A function to unsubscribe from the trade history updates
+   */
+  subscribeByAddr(subAddr: string, onData: (data: UserFundingHistoryWsMessage) => void) {
+    const topic = `user_funding_rate_history:${subAddr}`;
+
+    return this.deps.ws.subscribe(topic, UserFundingHistoryWsMessageSchema, onData);
+  }
+}

package/src/read/user-funding-history/user-funding-history.types.ts

@@ -0,0 +1,29 @@
+import z from "zod/v4";
+
+import { BaseRequestArgs } from "../base-reader";
+
+export interface UserFundingHistoryRequestArgs extends BaseRequestArgs {
+  subAddr: string;
+  limit?: number;
+}
+
+export const UserFundingSchema = z.object({
+  market: z.string(),
+  action: z.string(),
+  size: 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(),
+});
+
+export const UserFundingHistorySchema = z.array(UserFundingSchema);
+
+export const UserFundingHistoryWsMessageSchema = z.object({
+  funding_history: UserFundingHistorySchema,
+});
+
+export type UserFunding = z.infer<typeof UserFundingSchema>;
+export type UserFundingHistory = z.infer<typeof UserFundingHistorySchema>;
+export type UserFundingHistoryWsMessage = z.infer<typeof UserFundingHistoryWsMessageSchema>;

package/src/read/user-notifications/user-notifications.reader.ts

@@ -0,0 +1,17 @@
+import { BaseReader } from "../base-reader";
+import { UserNotification, UserNotificationSchema } from "./user-notifications.types";
+
+export class UserNotificationsReader extends BaseReader {
+  /**
+   * Subscribe to user positions updates
+   * @param subAddr The subaccount address of the user to subscribe to
+   * @param apiUrl The WebSocket server URL
+   * @param onData Callback function for received user positions data
+   * @returns A function to unsubscribe from the user positions updates
+   */
+  subscribeByAddr(subAddr: string, onData: (data: UserNotification) => void) {
+    const topic = `notifications:${subAddr}`;
+
+    return this.deps.ws.subscribe(topic, UserNotificationSchema, onData);
+  }
+}

package/src/read/user-notifications/user-notifications.types.ts

@@ -0,0 +1,61 @@
+import z from "zod/v4";
+
+import { UserActiveTwapSchema } from "../user-active-twaps/user-active-twaps.types";
+import { UserOrderSchema } from "../user-order-history/user-order-history.types";
+
+// from /rust/trading-api-dto/src/notification.rs
+export enum NotificationType {
+  MarketOrderPlaced = "MarketOrderPlaced",
+  LimitOrderPlaced = "LimitOrderPlaced",
+  StopMarketOrderPlaced = "StopMarketOrderPlaced",
+  StopMarketOrderTriggered = "StopMarketOrderTriggered",
+  StopLimitOrderPlaced = "StopLimitOrderPlaced",
+  StopLimitOrderTriggered = "StopLimitOrderTriggered",
+  OrderPartiallyFilled = "OrderPartiallyFilled",
+  OrderFilled = "OrderFilled",
+  OrderSizeReduced = "OrderSizeReduced",
+  OrderCancelled = "OrderCancelled",
+  OrderRejected = "OrderRejected",
+  OrderErrored = "OrderErrored",
+  TwapOrderPlaced = "TwapOrderPlaced",
+  TwapOrderTriggered = "TwapOrderTriggered",
+  TwapOrderCompleted = "TwapOrderCompleted",
+  TwapOrderCancelled = "TwapOrderCancelled",
+  TwapOrderErrored = "TwapOrderErrored",
+  AccountDeposit = "AccountDeposit",
+  AccountWithdrawal = "AccountWithdrawal",
+  TpSlSet = "TpSlSet",
+  TpHit = "TpHit",
+  SlHit = "SlHit",
+  TpCancelled = "TpCancelled",
+  SlCancelled = "SlCancelled",
+}
+
+export enum ClientNotificationType {
+  TwapPlaced = "TwapPlaced",
+  OrderCancellationPlaced = "OrderCancellationPlaced",
+  PositionCancellationPlaced = "PositionCancellationPlaced",
+  TwapCancellationPlaced = "TwapCancellationPlaced",
+  OrderCancellationErrored = "OrderCancellationErrored",
+  PositionCancellationErrored = "PositionCancellationErrored",
+  TwapCancellationErrored = "TwapCancellationErrored",
+}
+
+export const NotificationMetadataSchema = z.object({
+  trigger_price: z.number().optional(),
+  reason: z.string().optional(),
+  amount: z.number().optional(),
+  filled_size: z.number().optional(),
+});
+
+export const UserNotificationSchema = z.object({
+  notification: z.object({
+    account: z.string(),
+    notification_metadata: NotificationMetadataSchema.optional(),
+    notification_type: z.enum(NotificationType),
+    order: UserOrderSchema.optional(),
+    twap: UserActiveTwapSchema.optional(),
+  }),
+});
+
+export type UserNotification = z.infer<typeof UserNotificationSchema>;

package/src/read/user-open-orders/user-open-orders.reader.ts

@@ -0,0 +1,36 @@
+import { BaseReader } from "../base-reader";
+import {
+  UserOpenOrdersRequestArgs,
+  UserOpenOrdersSchema,
+  UserOpenOrdersWsMessage,
+  UserOpenOrdersWsMessageSchema,
+} from "./user-open-orders.types";
+
+export class UserOpenOrdersReader extends BaseReader {
+  /**
+   * Get the open orders for a given user
+   * @param subAddr The subaccount address of the user to get open orders for
+   * @returns The open orders for the given user
+   */
+  async getByAddr({ subAddr, fetchOptions }: UserOpenOrdersRequestArgs) {
+    const response = await this.getRequest({
+      schema: UserOpenOrdersSchema,
+      url: `${this.deps.config.tradingHttpUrl}/api/v1/open_orders`,
+      queryParams: { user: subAddr },
+      options: fetchOptions,
+    });
+
+    return response.data;
+  }
+
+  /**
+   * Subscribe to user orders updates
+   * @param subAddr The subaccount address of the user to subscribe to
+   * @param onData Callback function for received user orders data
+   * @returns A function to unsubscribe from the user orders updates
+   */
+  subscribeByAddr(subAddr: string, onData: (data: UserOpenOrdersWsMessage) => void) {
+    const topic = `user_open_orders:${subAddr}`;
+    return this.deps.ws.subscribe(topic, UserOpenOrdersWsMessageSchema, onData);
+  }
+}