Skip to main content
The WebSocketApi class provides real-time connectivity to the 1inch Fusion Mode WebSocket API for streaming order events and performing RPC calls.

​
Constructor

Creates a new WebSocket API instance. 
const ws = new WebSocketApi(config)
​
config
WsApiConfigWithNetwork | WsProviderConnector
required
Configuration object or custom WebSocket provider
​
config.url
string
required
WebSocket endpoint URL (e.g., wss://api.1inch.dev/fusion/ws)
​
config.network
NetworkEnum
required
Network to connect to (e.g., NetworkEnum.ETHEREUM)
​
config.authKey
string
Authentication key for API access
​
config.lazyInit
boolean
Defer connection until init() is called (default: false)

​
Static Methods

​
new

Alternative factory method for creating a WebSocket API instance. 
const ws = WebSocketApi.new(config)

​
Base Methods

​
init

Manually initializes the WebSocket connection (when lazyInit: true). 
ws.init()

​
on

Subscribes to a WebSocket event. 
ws.on('message', (data) => {
  console.log('Received:', data)
})
​
event
string
required
Event name to subscribe to
​
callback
Function
required
Callback function to handle the event

​
off

Unsubscribes from a WebSocket event. 
const handler = (data) => console.log(data)
ws.on('message', handler)
ws.off('message', handler)
​
event
string
required
Event name to unsubscribe from
​
callback
Function
required
Callback function to remove

​
onOpen

Subscribes to the connection open event. 
ws.onOpen(() => {
  console.log('Connection opened')
})
​
callback
Function
required
Callback function called when connection opens

​
onMessage

Subscribes to incoming messages. 
ws.onMessage((data) => {
  console.log('Message:', data)
})
​
callback
(data: any) => void
required
Callback function to handle messages

​
onClose

Subscribes to the connection close event. 
ws.onClose(() => {
  console.log('Connection closed')
})
​
callback
Function
required
Callback function called when connection closes

​
onError

Subscribes to error events. 
ws.onError((error) => {
  console.error('WebSocket error:', error)
})
​
callback
(error: any) => void
required
Callback function to handle errors

​
send

Sends a message through the WebSocket connection. 
ws.send({ type: 'ping' })
​
message
any
required
Message to send (will be JSON serialized)

​
close

Closes the WebSocket connection. 
ws.close()

​
Order Namespace

The order namespace provides methods for subscribing to order-related events.

​
onOrder

Subscribes to all order events. 
ws.order.onOrder((data) => {
  if (data.event === 'order_created') {
    console.log('New order:', data)
  }
  if (data.event === 'order_filled') {
    console.log('Order filled:', data)
  }
})
​
callback
(data: OrderEventType) => void
required
Callback function receiving order events

​
onOrderCreated

Subscribes to order creation events. 
ws.order.onOrderCreated((data) => {
  console.log('Order created:', data.data.orderHash)
})
​
callback
(data: OrderCreatedEvent) => void
required
Callback function receiving order_created events
Event Data:
  • orderHash - Order hash
  • signature - Order signature
  • order - Order structure
  • deadline - Order deadline
  • auctionStartDate - Auction start timestamp
  • auctionEndDate - Auction end timestamp
  • remainingMakerAmount - Remaining maker amount

​
onOrderInvalid

Subscribes to order invalidation events. 
ws.order.onOrderInvalid((data) => {
  console.log('Order invalid:', data.data.orderHash)
})
​
callback
(data: OrderInvalidEvent) => void
required
Callback function receiving order_invalid events
Event Data:
  • orderHash - Order hash that became invalid

​
onOrderBalanceOrAllowanceChange

Subscribes to balance or allowance change events. 
ws.order.onOrderBalanceOrAllowanceChange((data) => {
  console.log('Balance/Allowance changed:', data.data)
})
​
callback
(data: OrderBalanceOrAllowanceChangeEvent) => void
required
Callback function receiving order_balance_or_allowance_change events
Event Data:
  • orderHash - Order hash
  • remainingMakerAmount - Remaining maker amount
  • balance - Current balance
  • allowance - Current allowance

​
onOrderFilled

Subscribes to order filled events. 
ws.order.onOrderFilled((data) => {
  console.log('Order filled:', data.data.orderHash)
})
​
callback
(data: OrderFilledEvent) => void
required
Callback function receiving order_filled events
Event Data:
  • orderHash - Order hash that was filled

​
onOrderFilledPartially

Subscribes to partial fill events. 
ws.order.onOrderFilledPartially((data) => {
  console.log('Partial fill:', data.data.remainingMakerAmount)
})
​
callback
(data: OrderFilledPartiallyEvent) => void
required
Callback function receiving order_filled_partially events
Event Data:
  • orderHash - Order hash
  • remainingMakerAmount - Amount remaining after partial fill

​
onOrderCancelled

Subscribes to order cancellation events. 
ws.order.onOrderCancelled((data) => {
  console.log('Order cancelled:', data.data.orderHash)
})
​
callback
(data: OrderCancelledEvent) => void
required
Callback function receiving order_cancelled events
Event Data:
  • orderHash - Order hash that was cancelled

​
RPC Namespace

The rpc namespace provides methods for making RPC calls and receiving responses.

​
ping

Sends a ping request for health checking. 
ws.rpc.ping()

​
onPong

Subscribes to ping responses. 
ws.rpc.onPong((data) => {
  console.log('Pong received:', data)
})
​
callback
(data: string) => void
required
Callback function receiving pong responses

​
getAllowedMethods

Requests the list of allowed RPC methods. 
ws.rpc.getAllowedMethods()

​
onGetAllowedMethods

Subscribes to allowed methods responses. 
ws.rpc.onGetAllowedMethods((methods) => {
  console.log('Allowed methods:', methods)
})
​
callback
(data: RpcMethod[]) => void
required
Callback function receiving the list of allowed methods

​
getActiveOrders

Requests the list of active orders via WebSocket. 
ws.rpc.getActiveOrders()

​
onGetActiveOrders

Subscribes to active orders responses. 
ws.rpc.onGetActiveOrders((data) => {
  console.log('Active orders:', data.items)
})
​
callback
(data: PaginationOutput<ActiveOrder>) => void
required
Callback function receiving active orders data

​
Types

​
OrderEventType

Union type of all order events:
  • OrderCreatedEvent - Order created
  • OrderInvalidEvent - Order became invalid
  • OrderBalanceOrAllowanceChangeEvent - Balance or allowance changed
  • OrderFilledEvent - Order fully filled
  • OrderFilledPartiallyEvent - Order partially filled
  • OrderCancelledEvent - Order cancelled

​
RpcMethod

Allowed RPC methods:
  • getAllowedMethods
  • ping

​
Example

import { WebSocketApi, NetworkEnum } from '@1inch/fusion-sdk'

// Create WebSocket instance
const ws = new WebSocketApi({
  url: 'wss://api.1inch.dev/fusion/ws',
  network: NetworkEnum.ETHEREUM,
  authKey: 'your-auth-key'
})

// Subscribe to order events
ws.order.onOrderCreated((data) => {
  console.log('New order created:', data.data.orderHash)
})

ws.order.onOrderFilled((data) => {
  console.log('Order filled:', data.data.orderHash)
})

// Handle connection events
ws.onOpen(() => {
  console.log('Connected to WebSocket')
  ws.rpc.ping()
})

ws.onError((error) => {
  console.error('WebSocket error:', error)
})

// Lazy initialization example
const lazyWs = new WebSocketApi({
  url: 'wss://api.1inch.dev/fusion/ws',
  network: NetworkEnum.ETHEREUM,
  lazyInit: true
})

// Connect when ready
lazyWs.init()

Build docs developers (and LLMs) love

Get started for freeTalk to us