Pure WebSocket API
While developing our WebSocket service, we used Socket.IO and prepared an SDK for it. However, if you are going to use our service with a language other than TypeScript, you should find a Socket.IO interface for the language you will use, or you can learn how to connect to our service via standard WebSocket based on the TypeScript example below.
import TronSocket from './pure-ws'
const token = 'your-token-here'
const socket = new TronSocket(token)
socket
.connect()
.then(() => {
console.log('Connected')
socket.on('block', (block) => {
console.log(
'New block',
{
hash: block.blockHash,
number: block.blockNumber
}
)
})
})
.catch((error) => {
console.error('Failed to connect', error)
})import WebSocket from 'ws'
import { EventFilters, EventTypes } from '@tronsocket/types'
type EmitError = {
message: string
code: number
key?: string
}
type Events = keyof EventTypes
type Filters<E extends Events> = EventFilters[E]
type Callback<E extends Events> = (data: EventTypes[E]) => void
export default class TronSocket {
private token: string
private testnet: boolean
private socket: WebSocket | null = null
private socketUrl: string = 'wss://ws.tronsocket.com'
private connectionUrl: string
private listeners: { [key: string]: Callback<any>[] } = {}
constructor(token: string, testnet?: boolean) {
const api = new URL(this.socketUrl + '/socket.io/?EIO=4&transport=websocket')
api.searchParams.set('testnet', testnet ? 'true' : 'false')
api.searchParams.set('token', token)
this.connectionUrl = api.toString()
this.testnet = testnet || false
this.token = token
}
private parseData(data: WebSocket.Data): { type: string; payload: any } {
let message: string
// Convert different data types to string
if (typeof data === 'string') {
message = data
} else if (data instanceof ArrayBuffer) {
message = new TextDecoder().decode(data)
} else if (Array.isArray(data)) {
message = Buffer.concat(data).toString('utf-8')
} else if (data instanceof Buffer) {
message = data.toString('utf-8')
} else {
return { type: 'error', payload: { message: 'Unsupported data type', code: 500 } }
}
// Socket.IO message format: <packet type>[JSON data]
const match = message.match(/^(\d+)(.*)$/)
if (!match) {
return {
type: 'error',
payload: { message: 'Invalid message format', code: 500, rawData: message }
}
}
const [, packetType, packetData] = match
try {
let parsedData: any
// Parse the JSON data if it exists
if (packetData) {
parsedData = JSON.parse(packetData)
}
// Map Socket.IO packet types to our event types
switch (packetType) {
case '0': // Connect
return { type: 'connect', payload: parsedData }
case '1': // Disconnect
return { type: 'disconnect', payload: parsedData }
case '2': // Event
if (Array.isArray(parsedData) && parsedData.length > 0) {
return { type: parsedData[0], payload: parsedData.slice(1) }
}
return { type: 'event', payload: parsedData }
case '3': // Ack
return { type: 'ack', payload: parsedData }
case '4': // Error
return { type: 'error', payload: parsedData }
case '5': // Binary Event
return { type: 'binary_event', payload: parsedData }
case '6': // Binary Ack
return { type: 'binary_ack', payload: parsedData }
default:
return { type: 'unknown', payload: { packetType, data: parsedData } }
}
} catch (error) {
console.error('Failed to parse Socket.IO message:', error)
return {
type: 'error',
payload: {
message: 'Failed to parse Socket.IO message',
code: 500,
rawData: message
}
}
}
}
private createWsFormat(key: string, event: string, filter?: object): string {
if (!filter) {
return `42["${key}","${event}"]`
} else {
return `42["${key}","${event}",${JSON.stringify(filter)}]`
}
}
private simpleHash(str: string): string {
let hash = 0
for (let i = 0; i < str?.length; i++) {
const char = str.charCodeAt(i)
hash = (hash << 5) - hash + char
hash = hash & hash // Convert to 32-bit integer
}
return Math.abs(hash).toString(16)
}
private createEventKey<E extends Events>(
event: E,
callback: Callback<E>,
filter?: Filters<E>
): string {
const stringFilter = this.simpleHash(JSON.stringify(filter))
const stringFunction = this.simpleHash(callback.toString())
const definer = stringFilter + stringFunction
return event + `-${definer}`
}
private startListener(): void {
this.socket!.onmessage = (event) => {
const data = this.parseData(event.data)
if (data.payload?.packetType === '42') {
if (data.payload.data[0] === 'error') {
this.listeners['error']?.forEach((callback) => {
callback(data.payload.data[1])
})
} else {
const eventKey = data.payload.data[0]
const eventData = data.payload.data[1]
this.listeners[eventKey]?.forEach((callback) => {
callback(eventData)
})
}
}
}
}
public async connect(): Promise<boolean> {
return new Promise((resolve, reject) => {
this.socket = new WebSocket(this.connectionUrl)
this.socket.onmessage = (event) => {
const data = this.parseData(event.data)
if (data.type === 'error') {
reject(data.payload)
} else {
if (data.payload?.packetType === '42') {
if (data.payload.data[0] === 'error') {
reject(data.payload.data[1])
} else if (data.payload.data[0] === 'ready') {
this.startListener()
resolve(true)
} else if (data.payload?.packetType === '41') {
this.socket?.close()
}
}
}
}
this.socket.onopen = () => {
this.socket?.send('40') // for socket.io connection
}
this.socket.onerror = (error) => {
reject(error.message)
}
this.socket.onclose = (error) => {
reject(error.reason || error.code)
}
})
}
public async disconnect(): Promise<boolean> {
return new Promise((resolve, reject) => {
if (this.socket) {
this.socket.send('41') // for socket.io disconnection
this.socket.onclose = () => {
this.socket = null
resolve(true)
}
this.socket.close()
} else {
reject('Socket not connected')
}
})
}
public subscribe<E extends Events>(event: E, callback: Callback<E>, filter?: Filters<E>): void {
if (this.socket) {
const eventKey = this.createEventKey(event, callback, filter)
this.socket.send(this.createWsFormat('subscribe', eventKey, filter))
this.listeners[eventKey] = this.listeners[eventKey] || []
this.listeners[eventKey].push(callback)
} else {
throw new Error('Socket not connected')
}
}
public on<E extends Events>(event: E, callback: Callback<E>, filter?: Filters<E>): void {
this.subscribe(event, callback, filter)
}
public unsubscribe<E extends Events>(event: E, callback: Callback<E>, filter?: Filters<E>): void {
if (this.socket) {
const eventKey = this.createEventKey(event, callback, filter)
this.socket.send(this.createWsFormat('unsubscribe', eventKey, filter))
delete this.listeners[eventKey]
} else {
throw new Error('Socket not connected')
}
}
public off<E extends Events>(event: E, callback: Callback<E>, filter?: Filters<E>): void {
this.unsubscribe(event, callback, filter)
}
public error(callback: (error: EmitError) => void): void {
if (this.socket) {
this.listeners['error'] = this.listeners['error'] || []
this.listeners['error'].push(callback)
} else {
throw new Error('Socket not connected')
}
}
}
Last updated