lighter-ts-sdk 1.0.0

package/examples/account_info.ts

@@ -0,0 +1,12 @@
+//Get account index and balance from the client
+
+import { Account } from "../src/api/account-api";
+import { ApiClient } from "../src/api/api-client";
+
+async function main(): Promise<void> {
+  const client = new ApiClient();
+  const reponse = await client.get<Account>('/api/v1/account', { by: 'l1_address', value: process.env.L1_ADDRESS });
+  console.log(reponse.data);
+}
+
+main();

package/examples/create_cancel_order.ts

@@ -0,0 +1,74 @@
+import { SignerClient } from '../src/signer/wasm-signer-client';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+const API_KEY_PRIVATE_KEY = process.env['PRIVATE_KEY'];
+const ACCOUNT_INDEX = parseInt(process.env['ACCOUNT_INDEX'] || '0', 10);
+const API_KEY_INDEX = parseInt(process.env['API_KEY_INDEX'] || '0', 10);
+
+async function main(): Promise<void> {
+  if (!API_KEY_PRIVATE_KEY) {
+    console.error('PRIVATE_KEY environment variable is required');
+    return;
+  }
+
+  const client = new SignerClient({
+    url: BASE_URL,
+    privateKey: API_KEY_PRIVATE_KEY,
+    accountIndex: ACCOUNT_INDEX,
+    apiKeyIndex: API_KEY_INDEX,
+    wasmConfig: { wasmPath: 'wasm/lighter-signer.wasm' }
+  });
+
+  await client.initialize();
+  await (client as any).ensureWasmClient();
+
+  const err = client.checkClient();
+  if (err) {
+    console.error('CheckClient error:', err);
+    return;
+  }
+
+  // Create order
+  const [tx, txHash, createErr] = await client.createOrder({
+    marketIndex: 0,
+    clientOrderIndex: 123,
+    baseAmount: 1000,
+    price: 4500,
+    isAsk: true,
+    orderType: SignerClient.ORDER_TYPE_MARKET,
+    timeInForce: SignerClient.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+    reduceOnly: false,
+    triggerPrice: 0,
+  });
+
+  console.log('Create Order:', { tx, txHash, err: createErr });
+  if (createErr) {
+    throw new Error(createErr);
+  }
+
+  const [auth, authErr] = await client.createAuthTokenWithExpiry(SignerClient.DEFAULT_10_MIN_AUTH_EXPIRY);
+  console.log('Auth token:', auth);
+  if (authErr) {
+    throw new Error(authErr);
+  }
+
+  // Cancel order
+  const [cancelTx, cancelTxHash, cancelErr] = await client.cancelOrder({
+    marketIndex: 0,
+    orderIndex: 123,
+  });
+
+  console.log('Cancel Order:', { tx: cancelTx, txHash: cancelTxHash, err: cancelErr });
+  if (cancelErr) {
+    throw new Error(cancelErr);
+  }
+
+  await client.close();
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/create_market_order.ts

@@ -0,0 +1,42 @@
+import { SignerClient } from '../src/signer/wasm-signer-client';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+const API_KEY_PRIVATE_KEY = process.env['PRIVATE_KEY'];
+const ACCOUNT_INDEX = parseInt(process.env['ACCOUNT_INDEX'] || '0', 10);
+const API_KEY_INDEX = parseInt(process.env['API_KEY_INDEX'] || '0', 10);
+
+async function main(): Promise<void> {
+  if (!API_KEY_PRIVATE_KEY) {
+    console.error('PRIVATE_KEY environment variable is required');
+    return;
+  }
+
+  const client = new SignerClient({
+    url: BASE_URL,
+    privateKey: API_KEY_PRIVATE_KEY,
+    accountIndex: ACCOUNT_INDEX,
+    apiKeyIndex: API_KEY_INDEX,
+    wasmConfig: { wasmPath: 'wasm/lighter-signer.wasm' }
+  });
+
+  await client.initialize();
+  await (client as any).ensureWasmClient();
+
+  const [tx, txHash, err] = await client.createMarketOrder({
+    marketIndex: 0,
+    clientOrderIndex: Date.now(),
+    baseAmount: 10,
+    avgExecutionPrice: 4500,
+    isAsk: true,
+  });
+
+  console.log('Create Market Order:', { tx, txHash, err });
+  await client.close();
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/create_market_order_max_slippage.ts

@@ -0,0 +1,43 @@
+import { SignerClient } from '../src/signer/wasm-signer-client';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+const API_KEY_PRIVATE_KEY = process.env['PRIVATE_KEY'];
+const ACCOUNT_INDEX = parseInt(process.env['ACCOUNT_INDEX'] || '0', 10);
+const API_KEY_INDEX = parseInt(process.env['API_KEY_INDEX'] || '0', 10);
+
+async function main(): Promise<void> {
+  if (!API_KEY_PRIVATE_KEY) {
+    console.error('PRIVATE_KEY environment variable is required');
+    return;
+  }
+
+  const client = new SignerClient({
+    url: BASE_URL,
+    privateKey: API_KEY_PRIVATE_KEY,
+    accountIndex: ACCOUNT_INDEX,
+    apiKeyIndex: API_KEY_INDEX,
+    wasmConfig: { wasmPath: 'wasm/lighter-signer.wasm' }
+  });
+
+  await client.initialize();
+  await (client as any).ensureWasmClient();
+
+  // Create market order with price limit (similar to max slippage)
+  const [tx, txHash, err] = await client.createMarketOrder({
+    marketIndex: 0,
+    clientOrderIndex: Date.now(),
+    baseAmount: 30000000,
+    avgExecutionPrice: 300000, // This acts as a price limit
+    isAsk: true,
+  });
+
+  console.log('Create Market Order with Price Limit:', { tx, txHash, err });
+  await client.close();
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/create_sl_tp.ts

@@ -0,0 +1,61 @@
+import { SignerClient } from '../src/signer/wasm-signer-client';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+const API_KEY_PRIVATE_KEY = process.env['PRIVATE_KEY'];
+const ACCOUNT_INDEX = parseInt(process.env['ACCOUNT_INDEX'] || '0', 10);
+const API_KEY_INDEX = parseInt(process.env['API_KEY_INDEX'] || '0', 10);
+
+async function main(): Promise<void> {
+  if (!API_KEY_PRIVATE_KEY) {
+    console.error('API_KEY_PRIVATE_KEY environment variable is required');
+    return;
+  }
+
+  const client = new SignerClient({
+    url: BASE_URL,
+    privateKey: API_KEY_PRIVATE_KEY,
+    accountIndex: ACCOUNT_INDEX,
+    apiKeyIndex: API_KEY_INDEX,
+    wasmConfig: { wasmPath: 'wasm/lighter-signer.wasm' }
+  });
+
+  await client.initialize();
+  await (client as any).ensureWasmClient();
+
+  // Create Take Profit order (using limit order with trigger price)
+  const [tpTx, tpTxHash, tpErr] = await client.createOrder({
+    marketIndex: 0,
+    clientOrderIndex: Date.now(),
+    baseAmount: 1000,
+    price: 500000,
+    isAsk: false,
+    orderType: SignerClient.ORDER_TYPE_LIMIT,
+    timeInForce: SignerClient.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+    reduceOnly: false,
+    triggerPrice: 500000,
+  });
+  console.log('Create TP Order:', { tx: tpTx, txHash: tpTxHash, err: tpErr });
+
+  // Create Stop Loss order (using limit order with trigger price)
+  const [slTx, slTxHash, slErr] = await client.createOrder({
+    marketIndex: 0,
+    clientOrderIndex: Date.now() + 1,
+    baseAmount: 1000,
+    price: 500000,
+    isAsk: false,
+    orderType: SignerClient.ORDER_TYPE_LIMIT,
+    timeInForce: SignerClient.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+    reduceOnly: false,
+    triggerPrice: 500000,
+  });
+  console.log('Create SL Order:', { tx: slTx, txHash: slTxHash, err: slErr });
+
+  await client.close();
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/create_with_multiple_keys.ts

@@ -0,0 +1,58 @@
+import { SignerClient } from '../src/signer/wasm-signer-client';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+const ACCOUNT_INDEX = parseInt(process.env['ACCOUNT_INDEX'] || '0', 10);
+
+// Use examples/system_setup.ts or the apikeys page (for mainnet) to generate new api keys
+const KEYS: Record<number, string> = {
+  5: process.env['API_PRIVATE_KEY_5'] || '',
+  6: process.env['API_PRIVATE_KEY_6'] || '',
+  7: process.env['API_PRIVATE_KEY_7'] || '',
+};
+
+async function main(): Promise<void> {
+  const client = new SignerClient({
+    url: BASE_URL,
+    privateKey: KEYS[5],
+    accountIndex: ACCOUNT_INDEX,
+    apiKeyIndex: 5,
+    wasmConfig: { wasmPath: 'wasm/lighter-signer.wasm' }
+  });
+
+  await client.initialize();
+  await (client as any).ensureWasmClient();
+
+  const err = client.checkClient();
+  if (err) {
+    console.error('CheckClient error:', err);
+    return;
+  }
+
+  for (let i = 0; i < 5; i++) { // Reduced from 20 to 5 for demo
+    const [tx, txHash, createErr] = await client.createOrder({
+      marketIndex: 0,
+      clientOrderIndex: 123 + i,
+      baseAmount: 100000 + i,
+      price: 385000 + i,
+      isAsk: true,
+      orderType: SignerClient.ORDER_TYPE_LIMIT,
+      timeInForce: SignerClient.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+      reduceOnly: false,
+      triggerPrice: 0,
+    });
+    console.log({ tx, txHash, err: createErr });
+  }
+
+  const [cancelTx, cancelTxHash] = await client.cancelAllOrders(
+    SignerClient.CANCEL_ALL_TIF_IMMEDIATE, 
+    Date.now()
+  );
+  console.log('Cancel All Orders:', { tx: cancelTx, txHash: cancelTxHash });
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/get_info.ts

@@ -0,0 +1,58 @@
+import { ApiClient } from '../src/api/api-client';
+import { AccountApi } from '../src/api/account-api';
+import { BlockApi } from '../src/api/block-api';
+import { OrderApi } from '../src/api/order-api';
+import { TransactionApi } from '../src/api/transaction-api';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+const L1_ADDRESS = process.env['L1_ADDRESS'] || '0x8D7f03FdE1A626223364E592740a233b72395235';
+const ACCOUNT_INDEX = parseInt(process.env['ACCOUNT_INDEX'] || '65', 10);
+
+async function printApi(method: any, ...args: any[]): Promise<void> {
+  try {
+    const result = await method(...args);
+    console.log(`${method.name}:`, result);
+  } catch (error: any) {
+    console.log(`${method.name}: Error -`, error.message);
+  }
+}
+
+async function main(): Promise<void> {
+  const client = new ApiClient({ host: BASE_URL });
+  
+  console.log('=== ACCOUNT APIS ===');
+  const accountApi = new AccountApi(client);
+  await printApi(accountApi.getAccount.bind(accountApi), 'l1_address', L1_ADDRESS);
+  await printApi(accountApi.getAccount.bind(accountApi), 'index', ACCOUNT_INDEX.toString());
+  await printApi(accountApi.getAccountsByL1Address.bind(accountApi), L1_ADDRESS);
+  await printApi(accountApi.getApiKeys.bind(accountApi), ACCOUNT_INDEX, 1);
+  await printApi(accountApi.getPublicPools.bind(accountApi), 'all', 1, 0);
+
+  console.log('\n=== BLOCK APIS ===');
+  const blockApi = new BlockApi(client);
+  await printApi(blockApi.getBlock.bind(blockApi), 'height', '1');
+  await printApi(blockApi.getBlocks.bind(blockApi), 0, 2, 'asc');
+  await printApi(blockApi.getCurrentHeight.bind(blockApi));
+
+  console.log('\n=== ORDER APIS ===');
+  const orderApi = new OrderApi(client);
+  await printApi(orderApi.getExchangeStats.bind(orderApi));
+  await printApi(orderApi.getOrderBookDetails.bind(orderApi), { marketIndex: 0 });
+  await printApi(orderApi.getOrderBooks.bind(orderApi));
+  await printApi(orderApi.getRecentTrades.bind(orderApi), { marketIndex: 0, limit: 2 });
+
+  console.log('\n=== TRANSACTION APIS ===');
+  const transactionApi = new TransactionApi(client);
+  await printApi(transactionApi.getBlockTransactions.bind(transactionApi), { by: 'block_height', value: '1' });
+  await printApi(transactionApi.getNextNonce.bind(transactionApi), ACCOUNT_INDEX, 0);
+  await printApi(transactionApi.getTransactions.bind(transactionApi), { limit: 2 });
+
+  await client.close();
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/send_tx_batch.ts

@@ -0,0 +1,87 @@
+import { SignerClient } from '../src/signer/wasm-signer-client';
+import { TransactionApi } from '../src/api/transaction-api';
+import { ApiClient } from '../src/api/api-client';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+const API_KEY_PRIVATE_KEY = process.env['PRIVATE_KEY'];
+const ACCOUNT_INDEX = parseInt(process.env['ACCOUNT_INDEX'] || '0', 10);
+const API_KEY_INDEX = parseInt(process.env['API_KEY_INDEX'] || '0', 10);
+
+async function main(): Promise<void> {
+  if (!API_KEY_PRIVATE_KEY) {
+    console.error('PRIVATE_KEY environment variable is required');
+    return;
+  }
+
+  const apiClient = new ApiClient({ host: BASE_URL });
+  const transactionApi = new TransactionApi(apiClient);
+  const client = new SignerClient({
+    url: BASE_URL,
+    privateKey: API_KEY_PRIVATE_KEY,
+    accountIndex: ACCOUNT_INDEX,
+    apiKeyIndex: API_KEY_INDEX,
+    wasmConfig: { wasmPath: 'wasm/lighter-signer.wasm' }
+  });
+
+  await client.initialize();
+  await (client as any).ensureWasmClient();
+
+  const err = client.checkClient();
+  if (err) {
+    console.error('CheckClient error:', err);
+    return;
+  }
+
+  // Get next nonce
+  const nextNonce = await transactionApi.getNextNonce(ACCOUNT_INDEX, API_KEY_INDEX);
+  let nonceValue = nextNonce.nonce;
+
+  // Sign first order
+  const askTxInfo = await (client as any).wallet.signCreateOrder({
+    marketIndex: 0,
+    clientOrderIndex: 1001,
+    baseAmount: 100000,
+    price: 280000,
+    isAsk: 1,
+    orderType: SignerClient.ORDER_TYPE_LIMIT,
+    timeInForce: SignerClient.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+    reduceOnly: 0,
+    triggerPrice: 0,
+    nonce: nonceValue++
+  });
+
+  // Sign second order
+  const bidTxInfo = await (client as any).wallet.signCreateOrder({
+    marketIndex: 0,
+    clientOrderIndex: 1002,
+    baseAmount: 200000,
+    price: 200000,
+    isAsk: 0,
+    orderType: SignerClient.ORDER_TYPE_LIMIT,
+    timeInForce: SignerClient.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
+    reduceOnly: 0,
+    triggerPrice: 0,
+    nonce: nonceValue++
+  });
+
+  try {
+    const txHashes = await transactionApi.sendTransactionBatch({
+      account_index: ACCOUNT_INDEX,
+      api_key_index: API_KEY_INDEX,
+      transactions: [askTxInfo, bidTxInfo]
+    });
+    console.log('Batch transaction successful:', txHashes);
+  } catch (error: any) {
+    console.error('Error sending batch transaction:', error.message);
+  }
+
+  await client.close();
+  await apiClient.close();
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/system_setup.ts

@@ -0,0 +1,96 @@
+import { SignerClient } from '../src/signer/wasm-signer-client';
+import { ApiClient } from '../src/api/api-client';
+import { AccountApi } from '../src/api/account-api';
+import * as dotenv from 'dotenv';
+import { ethers } from 'ethers';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+const ETH_PRIVATE_KEY = process.env['ETH_PRIVATE_KEY'] || '1234567812345678123456781234567812345678123456781234567812345678';
+const API_KEY_INDEX = parseInt(process.env['API_KEY_INDEX'] || '3', 10);
+
+async function main(): Promise<void> {
+  // Verify that the account exists & fetch account index
+  const apiClient = new ApiClient({ host: BASE_URL });
+  const wallet = new ethers.Wallet(ETH_PRIVATE_KEY);
+  const ethAddress = wallet.address;
+
+  try {
+    const accountApi = new AccountApi(apiClient);
+    const response = await accountApi.getAccountsByL1Address(ethAddress);
+    
+    let accountIndex: number;
+    if (response && response.length > 1) {
+      for (const account of response) {
+        console.log(`Found accountIndex: ${account.index}`);
+      }
+      console.log('Multiple accounts found, using the first one');
+      accountIndex = parseInt(response[0]!.index, 10);
+    } else if (response && response.length === 1) {
+      accountIndex = parseInt(response[0]!.index, 10);
+    } else {
+      throw new Error('No accounts found for this L1 address');
+    }
+
+    // Create a SignerClient first
+    const txClient = new SignerClient({
+      url: BASE_URL,
+      privateKey: ETH_PRIVATE_KEY,
+      accountIndex: accountIndex,
+      apiKeyIndex: API_KEY_INDEX,
+      wasmConfig: { wasmPath: 'wasm/lighter-signer.wasm' }
+    });
+
+    await txClient.initialize();
+    await (txClient as any).ensureWasmClient();
+
+    // Create a private/public key pair for the new API key
+    const apiKeyResult = await txClient.generateAPIKey();
+    if (!apiKeyResult) {
+      throw new Error('Failed to generate API key');
+    }
+    const { privateKey, publicKey } = apiKeyResult;
+
+    // Change the API key
+    const [, err] = await txClient.changeApiKey({
+      ethPrivateKey: ETH_PRIVATE_KEY,
+      newPubkey: publicKey,
+    });
+
+    if (err) {
+      throw new Error(err);
+    }
+
+    // Wait some time so that we receive the new API key in the response
+    await new Promise(resolve => setTimeout(resolve, 10000));
+
+    // Check that the API key changed on the server
+    const checkErr = txClient.checkClient();
+    if (checkErr) {
+      throw new Error(checkErr);
+    }
+
+    console.log(`
+BASE_URL = '${BASE_URL}'
+API_KEY_PRIVATE_KEY = '${privateKey}'
+ACCOUNT_INDEX = ${accountIndex}
+API_KEY_INDEX = ${API_KEY_INDEX}
+    `);
+
+    await txClient.close();
+    await apiClient.close();
+
+  } catch (error: any) {
+    if (error.message === 'account not found') {
+      console.error(`Error: account not found for ${ethAddress}`);
+      return;
+    } else {
+      throw error;
+    }
+  }
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/transfer_update_leverage.ts

@@ -0,0 +1,53 @@
+import { SignerClient } from '../src/signer/wasm-signer-client';
+import { ApiClient } from '../src/api/api-client';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+const API_KEY_PRIVATE_KEY = process.env['PRIVATE_KEY'];
+const ACCOUNT_INDEX = parseInt(process.env['ACCOUNT_INDEX'] || '10', 10);
+const API_KEY_INDEX = parseInt(process.env['API_KEY_INDEX'] || '10', 10);
+
+async function main(): Promise<void> {
+  if (!API_KEY_PRIVATE_KEY) {
+    console.error('PRIVATE_KEY environment variable is required');
+    return;
+  }
+
+  const client = new SignerClient({
+    url: BASE_URL,
+    privateKey: API_KEY_PRIVATE_KEY,
+    accountIndex: ACCOUNT_INDEX,
+    apiKeyIndex: API_KEY_INDEX,
+    wasmConfig: { wasmPath: 'wasm/lighter-signer.wasm' }
+  });
+
+  const apiClient = new ApiClient({ host: BASE_URL });
+
+  await client.initialize();
+  await (client as any).ensureWasmClient();
+
+  const [authToken] = await client.createAuthTokenWithExpiry();
+  console.log('Auth token created:', authToken);
+
+  const err = client.checkClient();
+  if (err) {
+    console.error('CheckClient error:', err);
+    return;
+  }
+
+  const [levTx, levResponse, levErr] = await client.updateLeverage(4, SignerClient.CROSS_MARGIN_MODE, 3);
+  console.log('Update Leverage:', { tx: levTx, response: levResponse, err: levErr });
+
+  // Test transfer (requires proper fee calculation)
+  const [transferTx, transferResponse, transferErr] = await client.transfer(9, 100);
+  console.log('Transfer:', { tx: transferTx, response: transferResponse, err: transferErr });
+
+  await client.close();
+  await apiClient.close();
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/ws.ts

@@ -0,0 +1,24 @@
+import { WsClient } from '../src/api/ws-client';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+
+function onOrderBookUpdate(marketId: number, orderBook: any): void {
+  console.log(`Order book ${marketId}:`, JSON.stringify(orderBook, null, 2));
+}
+
+function onAccountUpdate(accountId: number, account: any): void {
+  console.log(`Account ${accountId}:`, JSON.stringify(account, null, 2));
+}
+
+const client = new WsClient({
+  url: BASE_URL,
+  orderBookIds: [0, 1],
+  accountIds: [1, 2],
+  onOrderBookUpdate,
+  onAccountUpdate,
+});
+
+client.run();

package/examples/ws_async.ts

@@ -0,0 +1,39 @@
+import { WsClient } from '../src/api/ws-client';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const BASE_URL = process.env['BASE_URL'] || 'https://mainnet.zklighter.elliot.ai';
+
+function onOrderBookUpdate(marketId: number, orderBook: any): void {
+  console.log(`Order book ${marketId}:`, JSON.stringify(orderBook, null, 2));
+}
+
+function onAccountUpdate(accountId: number, account: any): void {
+  console.log(`Account ${accountId}:`, JSON.stringify(account, null, 2));
+}
+
+async function main() {
+  const client = new WsClient({
+    url: BASE_URL,
+    onOpen: () => console.log('WebSocket connected'),
+    onMessage: (message) => {
+      console.log('Received message:', message);
+      // Handle different message types here
+    },
+    onClose: () => console.log('WebSocket closed'),
+    onError: (error) => console.error('WebSocket error:', error)
+  });
+
+  await client.connect();
+  
+  // Subscribe to order book updates
+  client.subscribe({ channel: 'orderbook', params: { market_id: 0 } });
+  client.subscribe({ channel: 'orderbook', params: { market_id: 1 } });
+  
+  // Subscribe to account updates
+  client.subscribe({ channel: 'account', params: { account_index: 1 } });
+  client.subscribe({ channel: 'account', params: { account_index: 2 } });
+}
+
+main().catch(console.error);