Interface KumaOrderEvent

  • subscription Websocket messages always include a type property which dictates the shape of its data property.
    • type will be the name of the subscription that the message correlates to.
    • Each Kuma<name>Event interface will document its provided data shape and properties.
  • subscriptions type messages will instead have a subscriptions property when dispatched.
  • Tip: Using the enum MessageEventType will make it easier to narrow the messages.
import {
  WebSocketClient,
  MessageEventType,
  SubscriptionNamePublic,
  type KumaMessageEvent,
  type KumaTickerEventData,
  type KumaSubscribeType,
} from '@kumabid/kuma-sdk';

const client = new WebSocketClient();

function handleSubscriptions(subscriptions: KumaSubscribeType[]) {
  // all subscribed subscriptions
  console.log('Active Subscriptions: ', subscriptions);
}

function handleTickersUpdate(message: KumaTickerEventData) {
  // handle the updated data
  console.log('Ticker: ', message);
}

client.onMessage((message: KumaMessageEvent) => {
  switch (message.type) {
    case MessageEventType.error:
      console.error(
        `[${message.data.code}] | Error received from WebSocketServer: ${message.data.message}`,
      );
      break;
    case MessageEventType.subscriptions:
      return handleSubscriptions(message.subscriptions);
    // narrows the type to the specific Kuma<name>Event type
    case MessageEventType.tickers:
      return handleTickersUpdate(message.data);
    default:
      break;
  }
});

async function main() {
  await client.connect();

  client.subscribePublic([
    {
      name: SubscriptionNamePublic.tickers,
      markets: ['ETH-USD'],
    },
  ]);
}

main().catch((error) => {
  console.error('Error During Startup: ', error);
});

See

KumaSubscriptionEventBase

interface KumaOrderEvent {
    type: "orders";
    data: KumaOrderEventData;
}

Hierarchy (view full)

Properties

type data

Properties

Readonly type

type: "orders"

The type property is used to determine the shape of the data property of the update event.

  • Subscription update events will match KumaSubscriptionEventBase with the subscription name as the value for the type property.
  • Otherwise the type will be:
    • subscriptions if you requested a list of all current subscriptions
    • error if your request resulted in a server error

See

enum MessageEventType

Readonly data

data: KumaOrderEventData

Order updates received from the WebSocket differ from orders retreived from the REST API in several ways.

  • In addition to the order types received when getting orders from the REST API, WebSocket update events may also provide the following undefined type indicating a KumaOrderEventDataSystemFill where the fills property will include a FillTypeSystem fill matching KumaOrderFillEventDataSystem
  • It is best to narrow on the type property between these types and all the others as shown in the example below.
    • This is made easiest by using the OrderType enum as shown.

Example

 import { OrderEventType } from '@kumabid/kuma-sdk';

 // ...

 const orderEventData = orderEvent.data

 if (
   orderEventData.type === OrderEventType.liquidation ||
   orderEventData.type === OrderEventType.deleverage
 ) {
   // orderEventData is of type KumaOrderEventDataLiquidation | KumaOrderEventDataDeleverage
 } else {
  // orderEventData is of type KumaOrderEventDataGeneral
 }

See

type KumaOrderEventData

Settings

Member Visibility

Theme

On This Page

typedata