perps-sdk-ts 1.0.1

package/examples/delegation-and-referrals.ts

@@ -0,0 +1,130 @@
+/**
+ * Delegation and Referrals Example
+ * Demonstrates delegation functionality and referral program
+ */
+
+import { TraderClient, toBlockchain10, toBlockchain6, toBlockchain18 } from '../src';
+
+async function main() {
+  // Initialize client
+  const client = new TraderClient('https://mainnet.base.org');
+  const privateKey = process.env.PRIVATE_KEY || '0x...';
+  client.setLocalSigner(privateKey);
+
+  const walletAddress = await client.signer?.getAddress();
+  console.log('Wallet address:', walletAddress);
+
+  // ==================== DELEGATION ====================
+
+  console.log('\n=== DELEGATION ===\n');
+
+  // 1. Set a delegate
+  console.log('1. Setting delegate...');
+  const delegateAddress = '0x...'; // Replace with actual delegate address
+
+  try {
+    const receipt = await client.delegation.setDelegate(delegateAddress);
+    console.log('Delegate set! Transaction hash:', receipt?.hash);
+  } catch (error) {
+    console.error('Error setting delegate:', error);
+  }
+
+  // 2. Check current delegate
+  console.log('\n2. Checking current delegate...');
+  const currentDelegate = await client.delegation.getDelegateFor(walletAddress!);
+  console.log('Current delegate:', currentDelegate);
+
+  // 3. Execute delegated action (as delegate)
+  console.log('\n3. Executing delegated action...');
+
+  // Example: Update TP/SL as delegate
+  const traderAddress = '0x...'; // Address you're delegating for
+  const newSl = toBlockchain10(47000);
+  const newTp = toBlockchain10(56000);
+
+  const callData = client.delegation.encodeUpdateTpAndSl(
+    0, // pairIndex
+    0, // tradeIndex
+    newSl,
+    newTp,
+    []
+  );
+
+  try {
+    const receipt = await client.delegation.delegatedAction(
+      traderAddress,
+      callData,
+      1n // 1 wei for price update
+    );
+
+    console.log('Delegated action executed! Transaction hash:', receipt?.hash);
+  } catch (error) {
+    console.error('Error executing delegated action:', error);
+  }
+
+  // 4. Remove delegate
+  console.log('\n4. Removing delegate...');
+
+  try {
+    const receipt = await client.delegation.removeDelegate();
+    console.log('Delegate removed! Transaction hash:', receipt?.hash);
+  } catch (error) {
+    console.error('Error removing delegate:', error);
+  }
+
+  // ==================== REFERRALS ====================
+
+  console.log('\n=== REFERRALS ===\n');
+
+  // 1. Set referral code
+  console.log('1. Setting referral code...');
+
+  try {
+    const receipt = await client.referral.setReferralCode('AVANTIS2024');
+    console.log('Referral code set! Transaction hash:', receipt?.hash);
+  } catch (error) {
+    console.error('Error setting referral code:', error);
+  }
+
+  // 2. Get referral info
+  console.log('\n2. Getting referral info...');
+  const referralInfo = await client.referral.getTraderReferralInfo(walletAddress!);
+  console.log('Referral code:', referralInfo.code);
+  console.log('Referrer address:', referralInfo.referrer);
+
+  // 3. Check if user has referral code
+  const hasCode = await client.referral.hasReferralCode(walletAddress!);
+  console.log('Has referral code:', hasCode);
+
+  // 4. Get referrer tier
+  if (referralInfo.referrer !== '0x0000000000000000000000000000000000000000') {
+    const tier = await client.referral.getReferrerTier(referralInfo.referrer);
+    console.log('Referrer tier:', tier);
+
+    // Get tier details
+    const tierInfo = await client.referral.getTierInfo(tier);
+    console.log('Tier info:', {
+      feeDiscountPct: tierInfo.feeDiscountPct,
+      refRebatePct: tierInfo.refRebatePct,
+    });
+  }
+
+  // 5. Calculate referral discount
+  console.log('\n5. Calculating referral discount...');
+  const baseFee = 1000000; // 1 USDC in 6 decimals
+  const discount = await client.referral.getTraderReferralDiscount(walletAddress!, baseFee);
+
+  console.log('Discount info:', {
+    traderDiscount: discount.traderDiscount,
+    referrer: discount.referrer,
+    rebateShare: discount.rebateShare,
+  });
+
+  // 6. Get effective fee after discount
+  const effectiveFee = await client.referral.getEffectiveFee(walletAddress!, baseFee);
+  console.log('Original fee:', baseFee);
+  console.log('Effective fee after discount:', effectiveFee);
+}
+
+// Run the example
+main().catch(console.error);

package/examples/get-pyth-ids.ts

@@ -0,0 +1,61 @@
+/**
+ * Simple example - Get Pyth feed IDs from the SDK
+ *
+ * This shows how to retrieve Pyth feed IDs that are stored
+ * in the trading pair storage contract.
+ */
+
+import { TraderClient } from '../src';
+
+async function main() {
+  // Initialize the trading client
+  const providerUrl = 'https://base-rpc.publicnode.com';
+  const client = new TraderClient(providerUrl);
+
+  console.log('Fetching Pyth feed IDs from pair storage contract...\n');
+
+  // Method 1: Get Pyth ID for a specific pair
+  console.log('=== Method 1: Get Pyth ID for a specific pair ===');
+
+  const btcPairIndex = await client.pairsCache.getPairIndex('BTC/USD');
+
+  if (btcPairIndex !== undefined) {
+    const btcPairData = await client.pairsCache.getPairBackend(btcPairIndex);
+
+    console.log('Pair: BTC/USD');
+    console.log('Pair Index:', btcPairIndex);
+    console.log('Pyth Feed ID:', btcPairData.pair.feed.feedId);
+    console.log('Backup Feed (Chainlink):', btcPairData.pair.backupFeed.feedId);
+    console.log('');
+  }
+
+  // Method 2: Get ALL Pyth IDs as a map
+  console.log('=== Method 2: Get all Pyth IDs ===');
+
+  const allPairs = await client.pairsCache.getPairsInfo();
+  const pythIds: Record<string, string> = {};
+
+  for (const [pairIndex, pairInfo] of allPairs) {
+    const pairData = await client.pairsCache.getPairBackend(pairIndex);
+    const pairName = `${pairInfo.from}/${pairInfo.to}`;
+    pythIds[pairName] = pairData.pair.feed.feedId;
+  }
+
+  console.log('All Pyth Feed IDs:');
+  console.log(JSON.stringify(pythIds, null, 2));
+
+  // Method 3: Export as CSV format (useful for documentation)
+  console.log('\n=== Method 3: Export as CSV ===');
+  console.log('Pair,PairIndex,PythFeedID,BackupFeedID');
+
+  for (const [pairIndex, pairInfo] of allPairs) {
+    const pairData = await client.pairsCache.getPairBackend(pairIndex);
+    const pairName = `${pairInfo.from}/${pairInfo.to}`;
+    console.log(
+      `${pairName},${pairIndex},${pairData.pair.feed.feedId},${pairData.pair.backupFeed.feedId}`
+    );
+  }
+}
+
+// Run the example
+main().catch(console.error);

package/examples/kms-signer.ts

@@ -0,0 +1,31 @@
+/**
+ * Example using AWS KMS for secure transaction signing
+ */
+
+import { TraderClient } from '../src';
+
+async function main() {
+  // Initialize client
+  const providerUrl = 'https://your-rpc-endpoint.com';
+  const client = new TraderClient(providerUrl);
+
+  // Set up AWS KMS signer
+  const kmsKeyId = 'your-kms-key-id';
+  const region = 'us-east-1';
+  client.setAwsKmsSigner(kmsKeyId, region);
+
+  // Get address from KMS key
+  const address = await client.signer?.getAddress();
+  console.log('Trading from KMS-secured address:', address);
+
+  // Now you can use the client normally
+  // All transactions will be signed by AWS KMS
+  const balance = await client.getUsdcBalance(address!);
+  console.log('USDC Balance:', balance);
+
+  // The private key never leaves AWS KMS hardware security modules
+  console.log('Secure signing enabled via AWS KMS');
+}
+
+// Run the example
+main().catch(console.error);

package/examples/optimized-snapshot.ts

@@ -0,0 +1,153 @@
+/**
+ * Optimized Snapshot Example
+ * Demonstrates the optimized snapshot that uses getPairBackend() to reduce contract calls
+ */
+
+import { TraderClient, fromBlockchain10, fromBlockchain12 } from '../src';
+
+async function main() {
+  // Initialize client
+  const client = new TraderClient('https://mainnet.base.org');
+
+  console.log('=== OPTIMIZED SNAPSHOT DEMO ===\n');
+
+  // ==================== STANDARD SNAPSHOT ====================
+
+  console.log('1. Getting market snapshot (optimized)...');
+  const snapshot = await client.snapshotRPC.getSnapshot();
+
+  console.log('\nSnapshot groups:', Object.keys(snapshot.groups));
+
+  // Display first group
+  const firstGroupKey = Object.keys(snapshot.groups)[0];
+  if (firstGroupKey) {
+    const group = snapshot.groups[firstGroupKey];
+    console.log(`\n${firstGroupKey} details:`);
+    console.log('  Pairs in group:', Object.keys(group.pairs).length);
+    console.log('  Group OI:', group.openInterest);
+    console.log('  Group Utilization:', group.utilization);
+    console.log('  Group Skew:', group.skew);
+
+    // Display first pair in group
+    const firstPairName = Object.keys(group.pairs)[0];
+    if (firstPairName) {
+      const pair = group.pairs[firstPairName];
+      console.log(`\n  ${firstPairName} details:`);
+      console.log('    Max Leverage:', pair.pairInfo.maxLeverage);
+      console.log('    Spread:', pair.spread);
+      console.log('    Fee:', pair.fee?.feeP);
+      console.log('    OI:', pair.openInterest);
+      console.log('    Utilization:', pair.utilization);
+      console.log('    Depth Above:', pair.depth?.onePercentDepthAboveUsdc);
+      console.log('    Depth Below:', pair.depth?.onePercentDepthBelowUsdc);
+    }
+  }
+
+  // ==================== FULL BACKEND DATA ====================
+
+  console.log('\n\n2. Getting full backend data for a pair...');
+
+  // Get full backend data for BTC/USD (usually pair index 0)
+  const pairIndex = 0;
+  const fullData = await client.snapshotRPC.getPairFullData(pairIndex);
+
+  console.log('\nFull pair data structure:');
+  console.log('  Pair Config:');
+  console.log('    Feed ID:', fullData.pair.feed.feedId);
+  console.log('    Max Open Deviation:', fromBlockchain10(fullData.pair.feed.maxOpenDeviationP), '%');
+  console.log('    Max Close Deviation:', fromBlockchain10(fullData.pair.feed.maxCloseDeviationP), '%');
+  console.log('    Spread:', fromBlockchain10(fullData.pair.spreadP), '%');
+  console.log('    PnL Spread:', fromBlockchain10(fullData.pair.pnlSpreadP), '%');
+
+  console.log('\n  Leverage Config:');
+  console.log('    Min Leverage:', fromBlockchain10(fullData.pair.leverages.minLeverage), 'x');
+  console.log('    Max Leverage:', fromBlockchain10(fullData.pair.leverages.maxLeverage), 'x');
+  console.log('    PnL Min Leverage:', fromBlockchain10(fullData.pair.leverages.pnlMinLeverage), 'x');
+  console.log('    PnL Max Leverage:', fromBlockchain10(fullData.pair.leverages.pnlMaxLeverage), 'x');
+
+  console.log('\n  OI & Risk Config:');
+  console.log('    Max Long OI:', fromBlockchain10(fullData.pair.values.maxLongOiP), '%');
+  console.log('    Max Short OI:', fromBlockchain10(fullData.pair.values.maxShortOiP), '%');
+  console.log('    Group OI %:', fromBlockchain10(fullData.pair.values.groupOpenInterestPercentageP), '%');
+  console.log('    Max Wallet OI:', fromBlockchain10(fullData.pair.values.maxWalletOIP), '%');
+  console.log('    Max Gain:', fromBlockchain10(fullData.pair.values.maxGainP), '%');
+  console.log('    Max SL:', fromBlockchain10(fullData.pair.values.maxSlP), '%');
+  console.log('    Is USDC Aligned:', fullData.pair.values.isUSDCAligned);
+
+  console.log('\n  Group Info:');
+  console.log('    Name:', fullData.group.name);
+  console.log('    Max OI:', fromBlockchain10(fullData.group.maxOpenInterestP), '%');
+  console.log('    Dynamic Spread:', fullData.group.isSpreadDynamic);
+
+  console.log('\n  Fee Structure:');
+  console.log('    Open Fee:', fromBlockchain12(fullData.fee.openFeeP), '%');
+  console.log('    Close Fee:', fromBlockchain12(fullData.fee.closeFeeP), '%');
+  console.log('    Limit Order Fee:', fromBlockchain12(fullData.fee.limitOrderFeeP), '%');
+  console.log('    Min Lev Position:', fromBlockchain10(fullData.fee.minLevPosUSDC), 'USDC');
+
+  console.log('\n  PnL Fees:');
+  console.log('    Number of Tiers:', fullData.fee.pnlFees.numTiers.toString());
+  if (fullData.fee.pnlFees.tierP.length > 0) {
+    fullData.fee.pnlFees.tierP.forEach((tier, i) => {
+      console.log(`    Tier ${i}: ${fromBlockchain10(tier)}% -> Fee: ${fromBlockchain12(fullData.fee.pnlFees.feesP[i])}%`);
+    });
+  }
+
+  // ==================== ALL PAIRS FULL DATA ====================
+
+  console.log('\n\n3. Getting full backend data for all pairs...');
+
+  const allPairsData = await client.snapshotRPC.getAllPairsFullData();
+
+  console.log(`\nLoaded full data for ${allPairsData.size} pairs`);
+
+  // Get pair names
+  const pairs = await client.pairsCache.getPairsInfo();
+
+  // Display summary of all pairs
+  console.log('\nAll pairs summary:');
+  for (const [pairIdx, backendData] of allPairsData) {
+    const pairInfo = pairs.get(pairIdx);
+    if (pairInfo) {
+      const maxLev = fromBlockchain10(backendData.pair.leverages.maxLeverage);
+      const spreadP = fromBlockchain10(backendData.pair.spreadP);
+      const openFeeP = fromBlockchain12(backendData.fee.openFeeP);
+
+      console.log(`  ${pairInfo.from}/${pairInfo.to}:`);
+      console.log(`    Max Leverage: ${maxLev}x`);
+      console.log(`    Spread: ${spreadP}%`);
+      console.log(`    Open Fee: ${openFeeP}%`);
+      console.log(`    Group: ${backendData.group.name}`);
+    }
+  }
+
+  // ==================== PERFORMANCE COMPARISON ====================
+
+  console.log('\n\n4. Performance comparison...');
+  console.log('\nOld approach (multiple calls):');
+  console.log('  - getPairsInfo() - 1 call');
+  console.log('  - getGroupIndexes() - 1 call');
+  console.log('  - getOI() (asset) - N calls per pair');
+  console.log('  - getOI() (category) - N calls per group');
+  console.log('  - getMarginFee() - N calls per pair');
+  console.log('  - And many more...');
+  console.log('  TOTAL: ~10+ separate RPC calls');
+
+  console.log('\nNew optimized approach:');
+  console.log('  - getPairsInfo() - 1 call (to get count)');
+  console.log('  - getPairBackend() - N calls (but includes pair + group + fee)');
+  console.log('  - getOI() (dynamic data) - still needed');
+  console.log('  - getUtilization() (dynamic data) - still needed');
+  console.log('  - getSkew() (dynamic data) - still needed');
+  console.log('  TOTAL: Reduced by eliminating separate group and fee calls');
+
+  console.log('\nBenefits:');
+  console.log('  ✓ Fewer total RPC calls');
+  console.log('  ✓ All static config data in one call');
+  console.log('  ✓ Access to complete pair configuration');
+  console.log('  ✓ Better for batch operations');
+  console.log('  ✓ More efficient caching opportunities');
+}
+
+// Run the example
+main().catch(console.error);

package/examples/price-feed-with-sdk-ids.ts

@@ -0,0 +1,97 @@
+/**
+ * Price feed example - Get Pyth IDs from SDK and use with FeedClient
+ *
+ * This example demonstrates how to:
+ * 1. Fetch Pyth feed IDs from the trading pair storage contract
+ * 2. Use those IDs with the FeedClient to get real-time price updates
+ */
+
+import { TraderClient, FeedClient, PriceFeedResponse } from '../src';
+
+async function main() {
+  // Initialize the trading client
+  const providerUrl = 'https://base-rpc.publicnode.com';
+  const client = new TraderClient(providerUrl);
+
+  // Example 1: Get Pyth feed ID for a specific pair
+  console.log('=== Example 1: Get Pyth ID for BTC/USD ===');
+
+  // Get BTC/USD pair index
+  const btcPairIndex = await client.pairsCache.getPairIndex('BTC/USD');
+  console.log('BTC/USD pair index:', btcPairIndex);
+
+  if (btcPairIndex !== undefined) {
+    // Get the full pair backend data (includes feed IDs)
+    const pairData = await client.pairsCache.getPairBackend(btcPairIndex);
+
+    console.log('Primary Pyth Feed ID:', pairData.pair.feed.feedId);
+    console.log('Backup Feed ID (Chainlink):', pairData.pair.backupFeed.feedId);
+    console.log('Max Open Deviation:', pairData.pair.feed.maxOpenDeviationP);
+    console.log('Max Close Deviation:', pairData.pair.feed.maxCloseDeviationP);
+  }
+
+  // Example 2: Get Pyth IDs for ALL trading pairs
+  console.log('\n=== Example 2: Get Pyth IDs for all pairs ===');
+
+  const allPairs = await client.pairsCache.getPairsInfo();
+  const pairFeedsMap = new Map<string, string>();
+
+  for (const [pairIndex, pairInfo] of allPairs) {
+    // Get the full backend data for this pair
+    const pairData = await client.pairsCache.getPairBackend(pairIndex);
+    const pairName = `${pairInfo.from}/${pairInfo.to}`;
+    const feedId = pairData.pair.feed.feedId;
+
+    pairFeedsMap.set(pairName, feedId);
+    console.log(`${pairName}: ${feedId}`);
+  }
+
+  // Example 3: Use the Pyth IDs with FeedClient for real-time prices
+  console.log('\n=== Example 3: Connect to Pyth for real-time prices ===');
+
+  const feedClient = new FeedClient();
+
+  // Load the pair-to-feed mapping into FeedClient
+  feedClient.loadPairFeeds(pairFeedsMap);
+
+  // Register callbacks for specific pairs
+  const btcFeedId = feedClient.getFeedIdForPair('BTC/USD');
+  const ethFeedId = feedClient.getFeedIdForPair('ETH/USD');
+
+  if (btcFeedId) {
+    console.log('Registering callback for BTC/USD feed:', btcFeedId);
+    feedClient.registerPriceFeedCallback(btcFeedId, (priceData: PriceFeedResponse) => {
+      const price = Number(priceData.price.price) * Math.pow(10, priceData.price.expo);
+      console.log('BTC/USD Price Update:', {
+        price: price.toFixed(2),
+        confidence: priceData.price.conf,
+        timestamp: new Date(priceData.price.publishTime * 1000).toISOString(),
+      });
+    });
+  }
+
+  if (ethFeedId) {
+    console.log('Registering callback for ETH/USD feed:', ethFeedId);
+    feedClient.registerPriceFeedCallback(ethFeedId, (priceData: PriceFeedResponse) => {
+      const price = Number(priceData.price.price) * Math.pow(10, priceData.price.expo);
+      console.log('ETH/USD Price Update:', {
+        price: price.toFixed(2),
+        confidence: priceData.price.conf,
+        timestamp: new Date(priceData.price.publishTime * 1000).toISOString(),
+      });
+    });
+  }
+
+  // Connect to Pyth WebSocket and start receiving updates
+  console.log('\nConnecting to Pyth Network WebSocket...');
+  await feedClient.listenForPriceUpdates();
+
+  console.log('Connected! Listening for price updates...');
+  console.log('Press Ctrl+C to exit');
+
+  // Keep the process running
+  process.stdin.resume();
+}
+
+// Run the example
+main().catch(console.error);

package/examples/price-feed.ts

@@ -0,0 +1,36 @@
+/**
+ * Price feed example using WebSocket
+ *
+ * NOTE: For a complete example showing how to get Pyth feed IDs from the SDK,
+ * see: price-feed-with-sdk-ids.ts
+ */
+
+import { FeedClient, PriceFeedResponse } from '../src';
+
+async function main() {
+  // Create feed client
+  const feedClient = new FeedClient();
+
+  // Register callback for BTC/USD price feed
+  // You can get this ID from the SDK - see price-feed-with-sdk-ids.ts example
+  const btcFeedId = 'your-btc-feed-id-here'; // Or use client.pairsCache.getPairBackend()
+
+  feedClient.registerPriceFeedCallback(btcFeedId, (priceData: PriceFeedResponse) => {
+    const price = Number(priceData.price.price) * Math.pow(10, priceData.price.expo);
+    console.log('BTC/USD Price Update:', {
+      price: price,
+      confidence: priceData.price.conf,
+      timestamp: new Date(priceData.price.publishTime * 1000).toISOString(),
+    });
+  });
+
+  // Connect and listen for updates
+  console.log('Connecting to price feed...');
+  await feedClient.listenForPriceUpdates();
+
+  // Keep the process running
+  process.stdin.resume();
+}
+
+// Run the example
+main().catch(console.error);

package/examples/trading-operations.ts

@@ -0,0 +1,149 @@
+/**
+ * Trading Operations Example
+ * Demonstrates opening trades, closing trades, and updating positions
+ */
+
+import { TraderClient, TradeInputOrderType, MarginUpdateType } from '../src';
+
+async function main() {
+  // Initialize client (Base network)
+  const client = new TraderClient('https://mainnet.base.org');
+
+  // Set signer with private key
+  const privateKey = process.env.PRIVATE_KEY || '0x...';
+  client.setLocalSigner(privateKey);
+
+  const walletAddress = await client.signer?.getAddress();
+  console.log('Wallet address:', walletAddress);
+
+  // ==================== OPEN A TRADE ====================
+
+  console.log('\n1. Opening a trade...');
+
+  // Get execution fee
+  const executionFee = await client.tradingOps.getExecutionFee();
+  console.log('Execution fee:', executionFee, 'ETH');
+
+  // Define trade parameters
+  const trade = {
+    trader: walletAddress!,
+    pairIndex: 0, // BTC/USD
+    index: 0, // Will be assigned by contract
+    initialPosToken: 100, // 100 USDC collateral
+    positionSizeUSDC: 100,
+    openPrice: 50000, // $50,000 BTC price
+    buy: true, // Long position
+    leverage: 10, // 10x leverage
+    tp: 55000, // Take profit at $55,000
+    sl: 48000, // Stop loss at $48,000
+  };
+
+  const slippagePercent = 1; // 1% slippage tolerance
+
+  try {
+    const receipt = await client.tradingOps.openTrade(
+      trade,
+      TradeInputOrderType.MARKET,
+      slippagePercent,
+      executionFee
+    );
+
+    console.log('Trade opened! Transaction hash:', receipt?.hash);
+  } catch (error) {
+    console.error('Error opening trade:', error);
+  }
+
+  // ==================== QUERY OPEN TRADES ====================
+
+  console.log('\n2. Querying open trades...');
+
+  const tradeCount = await client.tradingOps.getOpenTradesCount(walletAddress!, 0);
+  console.log('Number of open trades:', tradeCount);
+
+  if (tradeCount > 0) {
+    // Get first trade
+    const openTrade = await client.tradingOps.getOpenTrade(walletAddress!, 0, 0);
+    console.log('Open trade:', {
+      leverage: openTrade.leverage,
+      openPrice: openTrade.openPrice,
+      tp: openTrade.tp,
+      sl: openTrade.sl,
+      isLong: openTrade.buy,
+    });
+
+    // Get additional trade info
+    const tradeInfo = await client.tradingOps.getOpenTradeInfo(walletAddress!, 0, 0);
+    console.log('Trade info:', {
+      openInterestUSDC: tradeInfo.openInterestUSDC,
+      lossProtection: tradeInfo.lossProtection,
+    });
+  }
+
+  // ==================== UPDATE TP/SL ====================
+
+  console.log('\n3. Updating take profit and stop loss...');
+
+  try {
+    const receipt = await client.tradingOps.updateTpAndSl(
+      0, // pairIndex
+      0, // tradeIndex
+      47000, // New SL: $47,000
+      56000, // New TP: $56,000
+      [] // Price update data (can be empty for now)
+    );
+
+    console.log('TP/SL updated! Transaction hash:', receipt?.hash);
+  } catch (error) {
+    console.error('Error updating TP/SL:', error);
+  }
+
+  // ==================== UPDATE MARGIN ====================
+
+  console.log('\n4. Adding margin to position...');
+
+  try {
+    const receipt = await client.tradingOps.updateMargin(
+      0, // pairIndex
+      0, // tradeIndex
+      MarginUpdateType.DEPOSIT,
+      50, // Add 50 USDC
+      []
+    );
+
+    console.log('Margin updated! Transaction hash:', receipt?.hash);
+  } catch (error) {
+    console.error('Error updating margin:', error);
+  }
+
+  // ==================== CLOSE TRADE ====================
+
+  console.log('\n5. Closing trade...');
+
+  try {
+    const receipt = await client.tradingOps.closeTradeMarket(
+      0, // pairIndex
+      0, // tradeIndex
+      150, // Close 150 USDC worth (full position if that's the total)
+      executionFee
+    );
+
+    console.log('Trade closed! Transaction hash:', receipt?.hash);
+  } catch (error) {
+    console.error('Error closing trade:', error);
+  }
+
+  // ==================== LIMIT ORDERS ====================
+
+  console.log('\n6. Checking limit orders...');
+
+  try {
+    const limitOrder = await client.tradingOps.getOpenLimitOrder(walletAddress!, 0, 0);
+    console.log('Limit order:', limitOrder);
+  } catch (error) {
+    // No limit order exists
+    console.log('No limit order found');
+  }
+}
+
+// Run the example
+main().catch(console.error);