lighter-ts-sdk 1.0.1 → 1.0.2

package/examples/close_all_positions.ts

@@ -0,0 +1,69 @@
+// Close all positions by creating opposite market orders
+// This example shows how to close all open positions
+
+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['API_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_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;
+  }
+
+  console.log('🔄 Closing all positions...');
+
+  // Close all positions
+  const [closedTransactions, , errors] = await client.closeAllPositions();
+
+  console.log('\n📊 Results:');
+  console.log(`   Positions closed: ${closedTransactions.length}`);
+  console.log(`   Errors: ${errors.length}`);
+
+  if (errors.length > 0) {
+    console.log('\n❌ Errors encountered:');
+    errors.forEach((error, index) => {
+      console.log(`   ${index + 1}. ${error}`);
+    });
+  }
+
+  if (closedTransactions.length > 0) {
+    console.log('\n✅ Successfully closed positions:');
+    closedTransactions.forEach((tx, index) => {
+      console.log(`   ${index + 1}. Market ${tx.MarketIndex}: ${tx.IsAsk ? 'Sell' : 'Buy'} ${tx.BaseAmount} units`);
+    });
+  }
+
+  if (closedTransactions.length === 0 && errors.length === 0) {
+    console.log('ℹ️  No open positions found to close.');
+  }
+
+  await client.close();
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/create_cancel_order.ts

@@ -36,9 +36,9 @@ async function main(): Promise<void> {
     marketIndex: 0,
     clientOrderIndex: 123,
     baseAmount: 1000,
-    price: 4500,
+    price: 450000,
     isAsk: true,
-    orderType: SignerClient.ORDER_TYPE_MARKET,
+    orderType: SignerClient.ORDER_TYPE_LIMIT,
     timeInForce: SignerClient.ORDER_TIME_IN_FORCE_GOOD_TILL_TIME,
     reduceOnly: false,
     triggerPrice: 0,
@@ -49,10 +49,31 @@ async function main(): Promise<void> {
     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);
+  console.log('✅ Order created successfully!');
+  console.log('📋 Order Details:');
+  console.log(`   Market Index: ${tx.MarketIndex}`);
+  console.log(`   Client Order Index: ${tx.ClientOrderIndex}`);
+  console.log(`   Base Amount: ${tx.BaseAmount}`);
+  console.log(`   Price: ${tx.Price}`);
+  console.log(`   Is Ask: ${tx.IsAsk ? 'Yes (Sell)' : 'No (Buy)'}`);
+  console.log(`   Order Type: ${tx.Type === 0 ? 'Limit' : 'Market'}`);
+  console.log(`   Time In Force: ${tx.TimeInForce === 1 ? 'Good Till Time' : 'Immediate or Cancel'}`);
+  console.log(`   Nonce: ${tx.Nonce}`);
+
+  // Wait for transaction confirmation if txHash is available
+  if (txHash) {
+    console.log('\n⏳ Waiting for transaction confirmation...');
+    try {
+      const confirmedTx = await client.waitForTransaction(txHash, 30000, 1000);
+      console.log('✅ Transaction confirmed!');
+      console.log(`   Hash: ${confirmedTx.hash}`);
+      console.log(`   Status: ${confirmedTx.status}`);
+      console.log(`   Block Height: ${confirmedTx.block_height}`);
+    } catch (waitError) {
+      console.log('⚠️ Transaction confirmation timeout or failed:', waitError instanceof Error ? waitError.message : 'Unknown error');
+    }
+  } else {
+    console.log('⚠️ No transaction hash available for confirmation');
   }
 
   // Cancel order
@@ -61,9 +82,28 @@ async function main(): Promise<void> {
     orderIndex: 123,
   });
 
-  console.log('Cancel Order:', { tx: cancelTx, txHash: cancelTxHash, err: cancelErr });
+  console.log('\nCancel Order:', { tx: cancelTx, txHash: cancelTxHash, err: cancelErr });
   if (cancelErr) {
-    throw new Error(cancelErr);
+    console.log('❌ Cancel order error:', cancelErr);
+  } else {
+    console.log('✅ Order cancelled successfully!');
+    console.log('📋 Cancel Order Details:');
+    console.log(`   Market Index: ${cancelTx.MarketIndex}`);
+    console.log(`   Order Index: ${cancelTx.OrderIndex}`);
+    console.log(`   Nonce: ${cancelTx.Nonce}`);
+
+    // Wait for cancellation transaction confirmation if txHash is available
+    if (cancelTxHash) {
+      console.log('\n⏳ Waiting for cancellation transaction confirmation...');
+      try {
+        const confirmedCancelTx = await client.waitForTransaction(cancelTxHash, 30000, 1000);
+        console.log('✅ Cancellation transaction confirmed!');
+        console.log(`   Hash: ${confirmedCancelTx.hash}`);
+        console.log(`   Status: ${confirmedCancelTx.status}`);
+      } catch (waitError) {
+        console.log('⚠️ Cancellation transaction confirmation timeout:', waitError instanceof Error ? waitError.message : 'Unknown error');
+      }
+    }
   }
 
   await client.close();

package/examples/create_market_order.ts

@@ -29,11 +29,52 @@ async function main(): Promise<void> {
     marketIndex: 0,
     clientOrderIndex: Date.now(),
     baseAmount: 10,
-    avgExecutionPrice: 4500,
+    avgExecutionPrice: 4500, 
     isAsk: true,
   });
 
   console.log('Create Market Order:', { tx, txHash, err });
+  if (err) {
+    console.error('❌ Market order failed:', err);
+  } else {
+    console.log('✅ Market order created successfully!');
+    console.log('📋 Order Details:');
+    console.log(`   Market Index: ${tx.MarketIndex}`);
+    console.log(`   Client Order Index: ${tx.ClientOrderIndex}`);
+    console.log(`   Base Amount: ${tx.BaseAmount}`);
+    console.log(`   Price: ${tx.Price}`);
+    console.log(`   Is Ask: ${tx.IsAsk ? 'Yes (Sell)' : 'No (Buy)'}`);
+    console.log(`   Order Type: ${tx.Type === 0 ? 'Limit' : 'Market'}`);
+    console.log(`   Nonce: ${tx.Nonce}`);
+
+    // Wait for transaction confirmation if txHash is available
+    if (txHash) {
+      console.log('\n⏳ Waiting for transaction confirmation...');
+      try {
+        const confirmedTx = await client.waitForTransaction(txHash, 30000, 1000);
+        console.log('✅ Transaction confirmed!');
+        console.log(`   Hash: ${confirmedTx.hash}`);
+        console.log(`   Status: ${confirmedTx.status}`);
+        console.log(`   Block Height: ${confirmedTx.block_height}`);
+      } catch (waitError) {
+        console.log('⚠️ Transaction confirmation failed:', waitError instanceof Error ? waitError.message : 'Unknown error');
+        
+        // Check if it's a timeout or actual failure
+        if (waitError instanceof Error) {
+          if (waitError.message.includes('did not confirm within')) {
+            console.log('   → This is a timeout - transaction may still be processing');
+          } else if (waitError.message.includes('failed with status')) {
+            console.log('   → This is a transaction failure - the order was rejected');
+          } else {
+            console.log('   → This is an API or network error');
+          }
+        }
+      }
+    } else {
+      console.log('⚠️ No transaction hash available for confirmation');
+    }
+  }
+
   await client.close();
 }
 

package/examples/create_market_order_if_slippage.ts

@@ -0,0 +1,69 @@
+// Create market order only if slippage is acceptable
+// This example shows how to create a market order that only executes if slippage is within limits
+
+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 market order only if slippage is acceptable
+  const [tx, txHash, err_result] = await client.createMarketOrder_ifSlippage({
+    marketIndex: 0, // ETH market
+    clientOrderIndex: Date.now(),
+    baseAmount: 1000000, // 0.001 ETH (in wei scale)
+    maxSlippage: 0.005, // 0.5% max slippage (very strict)
+    isAsk: false, // Buy order
+  });
+
+  console.log('Create Market Order if Slippage Acceptable:', { tx, txHash, err: err_result });
+  
+  if (err_result) {
+    console.log('❌ Order not created:', err_result);
+  } else {
+    console.log('✅ Order created successfully!');
+    console.log('📋 Order Details:');
+    console.log(`   Market Index: ${tx.MarketIndex}`);
+    console.log(`   Client Order Index: ${tx.ClientOrderIndex}`);
+    console.log(`   Base Amount: ${tx.BaseAmount}`);
+    console.log(`   Price: ${tx.Price}`);
+    console.log(`   Is Ask: ${tx.IsAsk ? 'Yes (Sell)' : 'No (Buy)'}`);
+    console.log(`   Order Type: ${tx.Type === 0 ? 'Limit' : 'Market'}`);
+    console.log(`   Time In Force: ${tx.TimeInForce === 0 ? 'Immediate or Cancel' : 'Good Till Time'}`);
+    console.log(`   Nonce: ${tx.Nonce}`);
+  }
+
+  await client.close();
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}
+

package/examples/create_market_order_max_slippage.ts

@@ -1,43 +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);
-}
+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 maximum slippage limit
+  const [tx, txHash, err] = await client.createMarketOrder_maxSlippage({
+    marketIndex: 0,
+    clientOrderIndex: Date.now(),
+    baseAmount: 1000000, // 0.001 ETH (in wei scale)
+    maxSlippage: 0.01, // 1% max slippage
+    isAsk: true, // Sell order
+  });
+
+  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

@@ -4,13 +4,13 @@ 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 API_KEY_PRIVATE_KEY = process.env['API_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');
+    console.error('API_PRIVATE_KEY environment variable is required');
     return;
   }
 
@@ -25,33 +25,118 @@ async function main(): Promise<void> {
   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 });
+  console.log('🎯 Creating Take Profit and Stop Loss orders...\n');
+
+  // Example: Assume we have a long position and want to set TP/SL
+  const marketIndex = 0; // ETH/USDC
+  const baseAmount = 1000000; // 0.001 ETH
+  const takeProfitPrice = 420000000; // $4200 (5% profit)
+  const stopLossPrice = 380000000; // $3800 (5% loss)
+  const clientOrderIndex = Date.now();
+
+  // Create Take Profit Limit order
+  console.log('📈 Creating Take Profit Limit Order...');
+  const [tpTx, tpTxHash, tpErr] = await client.createTpLimitOrder(
+    marketIndex,
+    clientOrderIndex,
+    baseAmount,
+    takeProfitPrice, // trigger price
+    takeProfitPrice, // limit price
+    true, // isAsk = true (sell order to take profit on long position)
+    true  // reduceOnly = true (closing position)
+  );
+
+  if (tpErr) {
+    console.error('❌ Take Profit order failed:', tpErr);
+  } else {
+    console.log('✅ Take Profit order created successfully!');
+    console.log(`   Order Index: ${tpTx.ClientOrderIndex}`);
+    console.log(`   Trigger Price: $${takeProfitPrice / 100000}`);
+    console.log(`   Limit Price: $${takeProfitPrice / 100000}`);
+    console.log(`   Amount: ${baseAmount} units`);
+    console.log(`   TX Hash: ${tpTxHash}`);
+
+    // Wait for transaction confirmation if txHash is available
+    if (tpTxHash) {
+      console.log('⏳ Waiting for Take Profit transaction confirmation...');
+      try {
+        const confirmedTx = await client.waitForTransaction(tpTxHash, 30000, 1000);
+        console.log('✅ Take Profit transaction confirmed!');
+        console.log(`   Hash: ${confirmedTx.hash}`);
+        console.log(`   Status: ${confirmedTx.status}\n`);
+      } catch (waitError) {
+        console.log('⚠️ Take Profit transaction confirmation timeout:', waitError instanceof Error ? waitError.message : 'Unknown error\n');
+      }
+    } else {
+      console.log('⚠️ No transaction hash available for Take Profit confirmation\n');
+    }
+  }
+
+  // Create Stop Loss order (market order) - Note: Currently has issues with expiry validation
+  console.log('🛡️ Creating Stop Loss Order...');
+  console.log('⚠️  Note: Stop Loss market orders currently have expiry validation issues');
+  console.log('   Consider using Stop Loss Limit orders instead for better reliability\n');
+  
+  // Uncomment the following code when the Stop Loss market order issue is resolved:
+  /*
+  const [slTx, slTxHash, slErr] = await client.createSlOrder(
+    marketIndex,
+    clientOrderIndex + 1,
+    baseAmount,
+    stopLossPrice, // trigger price
+    0, // price = 0 for market order
+    true, // isAsk = true (sell order to stop loss on long position)
+    true  // reduceOnly = true (closing position)
+  );
+
+  if (slErr) {
+    console.error('❌ Stop Loss order failed:', slErr);
+  } else {
+    console.log('✅ Stop Loss order created successfully!');
+    console.log(`   Order Index: ${slTx.ClientOrderIndex}`);
+    console.log(`   Trigger Price: $${stopLossPrice / 100000}`);
+    console.log(`   Amount: ${baseAmount} units`);
+    console.log(`   TX Hash: ${slTxHash}\n`);
+  }
+  */
+
+  // Create Stop Loss Limit order (alternative to market order)
+  console.log('🛡️ Creating Stop Loss Limit Order...');
+  const [slLimitTx, slLimitTxHash, slLimitErr] = await client.createSlLimitOrder(
+    marketIndex,
+    clientOrderIndex + 2,
+    baseAmount,
+    stopLossPrice, // trigger price
+    stopLossPrice - 1000000, // limit price (slightly below trigger)
+    true, // isAsk = true (sell order to stop loss on long position)
+    true  // reduceOnly = true (closing position)
+  );
+
+  if (slLimitErr) {
+    console.error('❌ Stop Loss Limit order failed:', slLimitErr);
+  } else {
+    console.log('✅ Stop Loss Limit order created successfully!');
+    console.log(`   Order Index: ${slLimitTx.ClientOrderIndex}`);
+    console.log(`   Trigger Price: $${stopLossPrice / 100000}`);
+    console.log(`   Limit Price: $${(stopLossPrice - 1000000) / 100000}`);
+    console.log(`   Amount: ${baseAmount} units`);
+    console.log(`   TX Hash: ${slLimitTxHash}`);
+
+    // Wait for transaction confirmation if txHash is available
+    if (slLimitTxHash) {
+      console.log('⏳ Waiting for Stop Loss Limit transaction confirmation...');
+      try {
+        const confirmedTx = await client.waitForTransaction(slLimitTxHash, 30000, 1000);
+        console.log('✅ Stop Loss Limit transaction confirmed!');
+        console.log(`   Hash: ${confirmedTx.hash}`);
+        console.log(`   Status: ${confirmedTx.status}\n`);
+      } catch (waitError) {
+        console.log('⚠️ Stop Loss Limit transaction confirmation timeout:', waitError instanceof Error ? waitError.message : 'Unknown error\n');
+      }
+    } else {
+      console.log('⚠️ No transaction hash available for Stop Loss Limit confirmation\n');
+    }
+  }
 
   await client.close();
 }

package/examples/create_with_multiple_keys.ts

@@ -1,58 +1,77 @@
-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);
-}
+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'] || '',
+};
+
+// Check if required keys are available
+const requiredKey = KEYS[5];
+if (!requiredKey) {
+  console.error('API_PRIVATE_KEY_5 environment variable is required');
+  process.exit(1);
+}
+
+async function main(): Promise<void> {
+  const client = new SignerClient({
+    url: BASE_URL,
+    privateKey: requiredKey!,
+    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 });
+    
+    if (!createErr && txHash) {
+      console.log('⏳ Waiting for transaction confirmation...');
+      try {
+        const confirmedTx = await client.waitForTransaction(txHash, 30000, 1000);
+        console.log('✅ Transaction confirmed!');
+        console.log(`   Hash: ${confirmedTx.hash}`);
+        console.log(`   Status: ${confirmedTx.status}`);
+      } catch (waitError) {
+        console.log('⚠️ Transaction confirmation timeout:', waitError instanceof Error ? waitError.message : 'Unknown error');
+      }
+    }
+  }
+
+  const [cancelTx, cancelApiResponse, cancelErr] = await client.cancelAllOrders(
+    SignerClient.CANCEL_ALL_TIF_IMMEDIATE, 
+    Date.now()
+  );
+  console.log('Cancel All Orders:', { tx: cancelTx, apiResponse: cancelApiResponse, err: cancelErr });
+}
+
+if (require.main === module) {
+  main().catch(console.error);
+}

package/examples/get_info.ts

@@ -8,7 +8,7 @@ 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 L1_ADDRESS = process.env['L1_ADDRESS'] || '0x23bc4Dc9172d15Bbe02E57C0269EcD46c007EB95';
 const ACCOUNT_INDEX = parseInt(process.env['ACCOUNT_INDEX'] || '65', 10);
 
 async function printApi(method: any, ...args: any[]): Promise<void> {