perps-sdk-ts 1.0.1

package/dist/types.js

@@ -0,0 +1,245 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReferralDiscountSchema = exports.ReferralTierSchema = exports.OpenLimitOrderSchema = exports.TradeInfoSchema = exports.TradeSchema = exports.SnapshotSchema = exports.GroupSchema = exports.PairDataSchema = exports.LossProtectionInfoSchema = exports.DepthSchema = exports.FeeSchema = exports.SkewSchema = exports.UtilizationSchema = exports.OpenInterestLimitsSchema = exports.OpenInterestSchema = exports.PriceFeedResponseSchema = exports.EmaPriceSchema = exports.PriceSchema = exports.TradeResponseSchema = exports.TradeInputSchema = exports.PairInfoSchema = exports.SpreadSchema = exports.MarginUpdateType = exports.TradeInputOrderType = void 0;
+exports.fromBlockchain10 = fromBlockchain10;
+exports.fromBlockchain6 = fromBlockchain6;
+exports.toBlockchain10 = toBlockchain10;
+exports.toBlockchain6 = toBlockchain6;
+exports.fromBlockchain12 = fromBlockchain12;
+exports.toBlockchain12 = toBlockchain12;
+exports.fromBlockchain18 = fromBlockchain18;
+exports.toBlockchain18 = toBlockchain18;
+const zod_1 = require("zod");
+// ========== ENUMS ==========
+var TradeInputOrderType;
+(function (TradeInputOrderType) {
+    TradeInputOrderType["MARKET"] = "market";
+    TradeInputOrderType["STOP_LIMIT"] = "stop_limit";
+    TradeInputOrderType["LIMIT"] = "limit";
+    TradeInputOrderType["MARKET_ZERO_FEE"] = "market_zero_fee";
+})(TradeInputOrderType || (exports.TradeInputOrderType = TradeInputOrderType = {}));
+var MarginUpdateType;
+(function (MarginUpdateType) {
+    MarginUpdateType[MarginUpdateType["DEPOSIT"] = 0] = "DEPOSIT";
+    MarginUpdateType[MarginUpdateType["WITHDRAW"] = 1] = "WITHDRAW";
+})(MarginUpdateType || (exports.MarginUpdateType = MarginUpdateType = {}));
+// ========== ZOD SCHEMAS ==========
+// Address validation
+const addressSchema = zod_1.z.string().regex(/^0x[a-fA-F0-9]{40}$/);
+// Spread schema
+exports.SpreadSchema = zod_1.z.object({
+    min: zod_1.z.number(),
+    max: zod_1.z.number(),
+});
+// PairInfo schema
+exports.PairInfoSchema = zod_1.z.object({
+    from: zod_1.z.string(),
+    to: zod_1.z.string(),
+    spread: exports.SpreadSchema,
+    groupIndex: zod_1.z.number(),
+    feeIndex: zod_1.z.number(),
+    maxLeverage: zod_1.z.number(),
+    maxLongOiP: zod_1.z.number(),
+    maxShortOiP: zod_1.z.number(),
+    // maxOpenInterestUsdc: z.number(),
+});
+// TradeInput schema
+exports.TradeInputSchema = zod_1.z.object({
+    pair: zod_1.z.string(),
+    isLong: zod_1.z.boolean(),
+    collateralInTrade: zod_1.z.number(),
+    leverage: zod_1.z.number(),
+    openPrice: zod_1.z.number(),
+    tp: zod_1.z.number(),
+    sl: zod_1.z.number(),
+    referrer: addressSchema.optional().default('0x0000000000000000000000000000000000000000'),
+    orderType: zod_1.z.nativeEnum(TradeInputOrderType),
+    maxSlippageP: zod_1.z.number(),
+});
+// TradeResponse schema
+exports.TradeResponseSchema = zod_1.z.object({
+    trader: addressSchema,
+    pairIndex: zod_1.z.number(),
+    index: zod_1.z.number(),
+    initialPosUsdc: zod_1.z.number(),
+    openPrice: zod_1.z.number(),
+    buy: zod_1.z.boolean(),
+    leverage: zod_1.z.number(),
+    tp: zod_1.z.number(),
+    sl: zod_1.z.number(),
+});
+// Price schema (from Pyth)
+exports.PriceSchema = zod_1.z.object({
+    price: zod_1.z.string(),
+    conf: zod_1.z.string(),
+    expo: zod_1.z.number(),
+    publishTime: zod_1.z.number(),
+});
+// EmaPrice schema
+exports.EmaPriceSchema = zod_1.z.object({
+    price: zod_1.z.string(),
+    conf: zod_1.z.string(),
+    expo: zod_1.z.number(),
+    publishTime: zod_1.z.number(),
+});
+// PriceFeedResponse schema
+exports.PriceFeedResponseSchema = zod_1.z.object({
+    id: zod_1.z.string(),
+    price: exports.PriceSchema,
+    emaPrice: exports.EmaPriceSchema,
+});
+// OpenInterest schema
+exports.OpenInterestSchema = zod_1.z.object({
+    long: zod_1.z.number(),
+    short: zod_1.z.number(),
+    max: zod_1.z.number(),
+});
+// OpenInterestLimits schema
+exports.OpenInterestLimitsSchema = zod_1.z.object({
+    pairIndex: zod_1.z.number(),
+    maxLong: zod_1.z.number(),
+    maxShort: zod_1.z.number(),
+});
+// Utilization schema
+exports.UtilizationSchema = zod_1.z.object({
+    utilizationLong: zod_1.z.number(),
+    utilizationShort: zod_1.z.number(),
+});
+// Skew schema
+exports.SkewSchema = zod_1.z.object({
+    skew: zod_1.z.number(),
+});
+// Fee schema
+exports.FeeSchema = zod_1.z.object({
+    feeP: zod_1.z.number(),
+});
+// Depth schema
+exports.DepthSchema = zod_1.z.object({
+    onePercentDepthAboveUsdc: zod_1.z.number(),
+    onePercentDepthBelowUsdc: zod_1.z.number(),
+});
+// LossProtectionInfo schema
+exports.LossProtectionInfoSchema = zod_1.z.object({
+    tier: zod_1.z.number(),
+    percentage: zod_1.z.number(),
+    amount: zod_1.z.number(),
+});
+// PairData schema (for snapshot)
+exports.PairDataSchema = zod_1.z.object({
+    pairInfo: exports.PairInfoSchema,
+    openInterest: exports.OpenInterestSchema.optional(),
+    utilization: exports.UtilizationSchema.optional(),
+    skew: exports.SkewSchema.optional(),
+    fee: exports.FeeSchema.optional(),
+    depth: exports.DepthSchema.optional(),
+    spread: zod_1.z.number().optional(),
+});
+// Group schema (for snapshot)
+exports.GroupSchema = zod_1.z.object({
+    groupIndex: zod_1.z.number(),
+    pairs: zod_1.z.record(zod_1.z.string(), exports.PairDataSchema),
+    openInterest: exports.OpenInterestSchema.optional(),
+    utilization: exports.UtilizationSchema.optional(),
+    skew: exports.SkewSchema.optional(),
+});
+// Snapshot schema
+exports.SnapshotSchema = zod_1.z.object({
+    groups: zod_1.z.record(zod_1.z.string(), exports.GroupSchema),
+});
+// Trade schema (from smart contract)
+exports.TradeSchema = zod_1.z.object({
+    trader: addressSchema,
+    pairIndex: zod_1.z.number(),
+    index: zod_1.z.number(),
+    initialPosToken: zod_1.z.number(), // 6 decimals
+    positionSizeUSDC: zod_1.z.number(), // 6 decimals
+    openPrice: zod_1.z.number(), // 10 decimals
+    buy: zod_1.z.boolean(),
+    leverage: zod_1.z.number(), // 10 decimals
+    tp: zod_1.z.number(), // 10 decimals
+    sl: zod_1.z.number(), // 10 decimals
+    timestamp: zod_1.z.number(),
+});
+// TradeInfo schema (from smart contract)
+exports.TradeInfoSchema = zod_1.z.object({
+    openInterestUSDC: zod_1.z.number(), // 6 decimals
+    tpLastUpdated: zod_1.z.number(),
+    slLastUpdated: zod_1.z.number(),
+    beingMarketClosed: zod_1.z.boolean(),
+    lossProtection: zod_1.z.number(),
+});
+// OpenLimitOrder schema (from smart contract)
+exports.OpenLimitOrderSchema = zod_1.z.object({
+    trader: addressSchema,
+    pairIndex: zod_1.z.number(),
+    index: zod_1.z.number(),
+    positionSize: zod_1.z.number(), // 6 decimals
+    buy: zod_1.z.boolean(),
+    leverage: zod_1.z.number(), // 10 decimals
+    tp: zod_1.z.number(), // 10 decimals
+    sl: zod_1.z.number(), // 10 decimals
+    price: zod_1.z.number(), // 10 decimals
+    slippageP: zod_1.z.number(), // 10 decimals
+    block: zod_1.z.number(),
+    executionFee: zod_1.z.number(), // 18 decimals
+});
+// ReferralTier schema
+exports.ReferralTierSchema = zod_1.z.object({
+    feeDiscountPct: zod_1.z.number(),
+    refRebatePct: zod_1.z.number(),
+});
+// ReferralDiscount schema
+exports.ReferralDiscountSchema = zod_1.z.object({
+    traderDiscount: zod_1.z.number(),
+    referrer: addressSchema,
+    rebateShare: zod_1.z.number(),
+});
+// ========== CONVERSION HELPERS ==========
+/**
+ * Convert blockchain integer to decimal (10^10 precision)
+ */
+function fromBlockchain10(value) {
+    return Number(BigInt(value)) / 1e10;
+}
+/**
+ * Convert blockchain integer to decimal (10^6 precision for USDC)
+ */
+function fromBlockchain6(value) {
+    return Number(BigInt(value)) / 1e6;
+}
+/**
+ * Convert decimal to blockchain integer (10^10 precision)
+ */
+function toBlockchain10(value) {
+    return BigInt(Math.floor(value * 1e10));
+}
+/**
+ * Convert decimal to blockchain integer (10^6 precision for USDC)
+ */
+function toBlockchain6(value) {
+    return BigInt(Math.floor(value * 1e6));
+}
+/**
+ * Convert blockchain integer to decimal (10^12 precision for fees)
+ */
+function fromBlockchain12(value) {
+    return Number(BigInt(value)) / 1e12;
+}
+/**
+ * Convert decimal to blockchain integer (10^12 precision for fees)
+ */
+function toBlockchain12(value) {
+    return BigInt(Math.floor(value * 1e12));
+}
+/**
+ * Convert blockchain integer to decimal (10^18 precision for ETH/execution fees)
+ */
+function fromBlockchain18(value) {
+    return Number(BigInt(value)) / 1e18;
+}
+/**
+ * Convert decimal to blockchain integer (10^18 precision for ETH/execution fees)
+ */
+function toBlockchain18(value) {
+    return BigInt(Math.floor(value * 1e18));
+}

package/dist/utils.d.ts

@@ -0,0 +1,52 @@
+import { Result } from 'ethers';
+/**
+ * Utility functions for Web3 decoding and data processing
+ */
+/**
+ * Check if ABI type is a tuple
+ */
+export declare function isTupleType(abiType: string): boolean;
+/**
+ * Check if ABI type is an array
+ */
+export declare function isArrayType(abiType: string): boolean;
+/**
+ * Process ABI outputs and convert Result to object with named fields
+ */
+export declare function processOutputTypes(outputs: readonly any[], decoded: Result): Record<string, any>;
+/**
+ * Decode contract function output using ABI
+ * @param abi - Contract ABI
+ * @param functionName - Function name to decode
+ * @param output - Raw output data
+ * @returns Decoded output as object with named fields
+ */
+export declare function decoder(abi: any[], functionName: string, output: any): Record<string, any> | null;
+/**
+ * Convert hex string to number
+ */
+export declare function hexToNumber(hex: string): number;
+/**
+ * Convert number to hex string
+ */
+export declare function numberToHex(num: number): string;
+/**
+ * Validate Ethereum address
+ */
+export declare function isValidAddress(address: string): boolean;
+/**
+ * Format address to checksummed version
+ */
+export declare function toChecksumAddress(address: string): string;
+/**
+ * Sleep for specified milliseconds
+ */
+export declare function sleep(ms: number): Promise<void>;
+/**
+ * Retry function with exponential backoff
+ * @param fn - Async function to retry
+ * @param maxRetries - Maximum number of retries
+ * @param baseDelay - Base delay in milliseconds (default: 1000)
+ * @returns Result of the function
+ */
+export declare function retryWithBackoff<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number): Promise<T>;

package/dist/utils.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTupleType = isTupleType;
+exports.isArrayType = isArrayType;
+exports.processOutputTypes = processOutputTypes;
+exports.decoder = decoder;
+exports.hexToNumber = hexToNumber;
+exports.numberToHex = numberToHex;
+exports.isValidAddress = isValidAddress;
+exports.toChecksumAddress = toChecksumAddress;
+exports.sleep = sleep;
+exports.retryWithBackoff = retryWithBackoff;
+const ethers_1 = require("ethers");
+/**
+ * Utility functions for Web3 decoding and data processing
+ */
+/**
+ * Check if ABI type is a tuple
+ */
+function isTupleType(abiType) {
+    return abiType.startsWith('tuple');
+}
+/**
+ * Check if ABI type is an array
+ */
+function isArrayType(abiType) {
+    return abiType.endsWith('[]');
+}
+/**
+ * Process ABI outputs and convert Result to object with named fields
+ */
+function processOutputTypes(outputs, decoded) {
+    const result = {};
+    outputs.forEach((output, index) => {
+        const name = output.name || `output${index}`;
+        let value = decoded[index];
+        // Handle tuple types
+        if (isTupleType(output.type) && output.components) {
+            value = processOutputTypes(output.components, value);
+        }
+        // Handle array of tuples
+        else if (isArrayType(output.type) && output.baseType === 'tuple' && output.components) {
+            value = value.map((item) => processOutputTypes(output.components, item));
+        }
+        result[name] = value;
+    });
+    return result;
+}
+/**
+ * Decode contract function output using ABI
+ * @param abi - Contract ABI
+ * @param functionName - Function name to decode
+ * @param output - Raw output data
+ * @returns Decoded output as object with named fields
+ */
+function decoder(abi, functionName, output) {
+    try {
+        const iface = new ethers_1.Interface(abi);
+        const fragment = iface.getFunction(functionName);
+        if (!fragment) {
+            throw new Error(`Function ${functionName} not found in ABI`);
+        }
+        // If output is already decoded (Result type), process it
+        if (typeof output === 'object' && !Array.isArray(output) && output.toArray) {
+            return processOutputTypes(fragment.outputs, output);
+        }
+        // Decode the output
+        const decoded = iface.decodeFunctionResult(fragment, output);
+        // Process and return with named fields
+        return processOutputTypes(fragment.outputs, decoded);
+    }
+    catch (error) {
+        console.error(`Error decoding function ${functionName}:`, error);
+        return null;
+    }
+}
+/**
+ * Convert hex string to number
+ */
+function hexToNumber(hex) {
+    return parseInt(hex, 16);
+}
+/**
+ * Convert number to hex string
+ */
+function numberToHex(num) {
+    return '0x' + num.toString(16);
+}
+/**
+ * Validate Ethereum address
+ */
+function isValidAddress(address) {
+    return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+/**
+ * Format address to checksummed version
+ */
+function toChecksumAddress(address) {
+    if (!isValidAddress(address)) {
+        throw new Error('Invalid Ethereum address');
+    }
+    // ethers.js getAddress() returns checksummed address
+    return address;
+}
+/**
+ * Sleep for specified milliseconds
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Retry function with exponential backoff
+ * @param fn - Async function to retry
+ * @param maxRetries - Maximum number of retries
+ * @param baseDelay - Base delay in milliseconds (default: 1000)
+ * @returns Result of the function
+ */
+async function retryWithBackoff(fn, maxRetries = 3, baseDelay = 1000) {
+    let lastError;
+    for (let i = 0; i <= maxRetries; i++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (i < maxRetries) {
+                const delay = baseDelay * Math.pow(2, i);
+                console.log(`Retry ${i + 1}/${maxRetries} after ${delay}ms...`);
+                await sleep(delay);
+            }
+        }
+    }
+    throw lastError;
+}

package/examples/advanced-queries.ts

@@ -0,0 +1,181 @@
+/**
+ * Advanced Queries Example
+ * Demonstrates pair info queries and multicall functionality
+ */
+
+import { TraderClient } from '../src';
+
+async function main() {
+  // Initialize client
+  const client = new TraderClient('https://mainnet.base.org');
+
+  console.log('=== PAIR INFO QUERIES ===\n');
+
+  // ==================== PRICE IMPACT & SPREAD ====================
+
+  console.log('1. Calculating price impact and spread...');
+
+  const pairIndex = 0; // BTC/USD
+  const positionSize = 1000; // 1000 USDC
+  const isLong = true;
+
+  // Get price impact spread
+  const priceImpact = await client.pairInfoQueries.getPriceImpactSpread(
+    pairIndex,
+    isLong,
+    positionSize,
+    true // isOpen
+  );
+  console.log('Price impact spread:', priceImpact, '%');
+
+  // Get skew impact spread
+  const skewImpact = await client.pairInfoQueries.getSkewImpactSpread(
+    pairIndex,
+    isLong,
+    positionSize,
+    true
+  );
+  console.log('Skew impact spread:', skewImpact, '%');
+
+  // Get total price impact
+  const totalImpact = await client.pairInfoQueries.getPriceImpactP(pairIndex, isLong, positionSize);
+  console.log('Total price impact:', totalImpact, '%');
+
+  // ==================== FEES ====================
+
+  console.log('\n2. Calculating fees...');
+
+  // Get opening fee in USDC
+  const openFeeUsdc = await client.pairInfoQueries.getOpenFeeUsdc(pairIndex, positionSize, isLong);
+  console.log('Opening fee (USDC):', openFeeUsdc);
+
+  // Get opening fee percentage
+  const openFeeP = await client.pairInfoQueries.getOpenFeeP(pairIndex, positionSize, isLong);
+  console.log('Opening fee percentage:', openFeeP, '%');
+
+  // Get margin fee percentage
+  const marginFeeP = await client.pairInfoQueries.getPairMarginFeeP(pairIndex);
+  console.log('Margin fee percentage:', marginFeeP, '%');
+
+  // ==================== LOSS PROTECTION ====================
+
+  console.log('\n3. Checking loss protection...');
+
+  // Get loss protection tier for position size
+  const tier = await client.pairInfoQueries.getLossProtectionTierForSize(pairIndex, positionSize);
+  console.log('Loss protection tier:', tier);
+
+  // Get loss protection percentage
+  const protectionP = await client.pairInfoQueries.getLossProtectionP(pairIndex, tier);
+  console.log('Loss protection percentage:', protectionP, '%');
+
+  // ==================== LIQUIDITY DEPTH ====================
+
+  console.log('\n4. Checking liquidity depth...');
+
+  const depth = await client.pairInfoQueries.getDepth(pairIndex);
+  console.log('1% depth above (longs):', depth.above, 'USDC');
+  console.log('1% depth below (shorts):', depth.below, 'USDC');
+
+  // ==================== MULTICALL ====================
+
+  console.log('\n=== MULTICALL ===\n');
+
+  console.log('5. Batch reading multiple trades...');
+
+  const walletAddress = '0x...'; // Replace with actual address
+
+  // Get trading storage contract
+  const tradingStorage = client['contracts'].get('TradingStorage');
+
+  if (tradingStorage) {
+    // Batch read trades 0, 1, 2 for pair 0
+    const trades = await client.multicall.batchGetOpenTrades(
+      tradingStorage,
+      walletAddress,
+      0, // pairIndex
+      [0, 1, 2] // trade indices
+    );
+
+    console.log('Fetched', trades.length, 'trades in a single call');
+    trades.forEach((trade, i) => {
+      console.log(`Trade ${i}:`, {
+        openPrice: trade.openPrice.toString(),
+        leverage: trade.leverage.toString(),
+        buy: trade.buy,
+      });
+    });
+
+    // Batch read trade infos
+    console.log('\n6. Batch reading trade infos...');
+    const tradeInfos = await client.multicall.batchGetOpenTradesInfo(
+      tradingStorage,
+      walletAddress,
+      0,
+      [0, 1, 2]
+    );
+
+    console.log('Fetched', tradeInfos.length, 'trade infos');
+    tradeInfos.forEach((info, i) => {
+      console.log(`Trade ${i} info:`, {
+        openInterestUSDC: info.openInterestUSDC.toString(),
+        lossProtection: info.lossProtection.toString(),
+      });
+    });
+  }
+
+  // ==================== CUSTOM MULTICALL ====================
+
+  console.log('\n7. Custom multicall example...');
+
+  // Get pair storage contract
+  const pairStorage = client['contracts'].get('PairStorage');
+
+  if (pairStorage) {
+    // Read multiple pairs at once
+    const pairs = await client.multicall.batchGetPairs(pairStorage, [0, 1, 2, 3, 4]);
+
+    console.log('Fetched', pairs.length, 'pairs');
+    pairs.forEach((pair, i) => {
+      console.log(`Pair ${i}:`, {
+        from: pair.from,
+        to: pair.to,
+        maxLeverage: pair.maxLeverage.toString(),
+      });
+    });
+  }
+
+  // Advanced: Manual multicall with custom calls
+  console.log('\n8. Manual multicall with different contracts...');
+
+  const pairInfos = client['contracts'].get('PairInfos');
+  const referral = client['contracts'].get('Referral');
+
+  if (pairInfos && referral && tradingStorage) {
+    const result = await client.multicall.aggregateAndDecode([
+      {
+        contract: pairInfos,
+        functionName: 'onePercentDepthAboveUsdc',
+        args: [0],
+      },
+      {
+        contract: pairInfos,
+        functionName: 'onePercentDepthBelowUsdc',
+        args: [0],
+      },
+      {
+        contract: tradingStorage,
+        functionName: 'openInterestUsdc',
+        args: [0, 0],
+      },
+    ]);
+
+    console.log('Block number:', result.blockNumber);
+    console.log('Depth above:', result.results[0].toString());
+    console.log('Depth below:', result.results[1].toString());
+    console.log('Open interest:', result.results[2].toString());
+  }
+}
+
+// Run the example
+main().catch(console.error);

package/examples/basic-usage.ts

@@ -0,0 +1,78 @@
+/**
+ * Basic usage example for Avantis Trader SDK
+ */
+
+import { TraderClient, TradeInput, TradeInputOrderType } from '../src';
+
+async function main() {
+  // Initialize client with your RPC endpoint
+  const providerUrl = 'https://base-rpc.publicnode.com';
+  const client = new TraderClient(providerUrl);
+
+  // Set up signer with your private key (for local development)
+  const privateKey = '';
+  client.setLocalSigner(privateKey);
+
+  // Get your address
+  const address = await client.signer?.getAddress();
+  console.log('Trading from address:', address);
+
+  // Check USDC balance
+  const usdcBalance = await client.getUsdcBalance(address!);
+  console.log('USDC Balance:', usdcBalance);
+
+  // Check USDC allowance
+  const allowance = await client.getUsdcAllowanceForTrading(address!);
+  console.log('USDC Allowance:', allowance);
+
+  // Approve USDC if needed
+  if (allowance < 1000) {
+    console.log('Approving USDC...');
+    const approvalReceipt = await client.approveUsdcForTrading(10000); // Approve 10,000 USDC
+    console.log('Approval transaction hash:', approvalReceipt?.hash);
+
+    // Check allowance again after approval
+    const newAllowance = await client.getUsdcAllowanceForTrading(address!);
+    console.log('New USDC Allowance after approval:', newAllowance);
+  }
+
+  // // Get market snapshot
+  // console.log('Fetching market snapshot...');
+  // const snapshot = await client.snapshotRPC.getSnapshot();
+  // console.log('Snapshot:', JSON.stringify(snapshot, null, 2));
+
+  // // Get pair data
+  // const btcPair = await client.snapshotRPC.getPairSnapshot('BTC/USD');
+  // console.log('BTC/USD data:', btcPair);
+
+  // Create a trade
+  const tradeInput: TradeInput = {
+    pair: 'BTC/USD',
+    isLong: true,
+    collateralInTrade: 2, // 3 USDC (leave room for fees)
+    leverage: 10, // 10x leverage
+    openPrice: 0, // 0 = market order
+    tp: 0, // Take profit (0 = none)
+    sl: 0, // Stop loss (0 = none)
+    orderType: TradeInputOrderType.MARKET,
+
+    maxSlippageP: 1, // 1% max slippage
+    referrer: "0xca4d3f16a1deef067875ec01a9f683f67a91d947"
+  };
+
+  // // Build trade transaction
+  // console.log('Building trade transaction...');
+  // const tradeTx = await client.tradeRPC.buildTradeOpenTx(tradeInput, address!);
+
+  // // Sign and send transaction
+  // console.log('Sending trade...');
+  // const receipt = await client.signAndGetReceipt(tradeTx);
+  // console.log('Trade executed! Transaction hash:', receipt?.hash);
+
+  // Get your open trades
+  const trades = await client.tradeRPC.getTrades(address!);
+  console.log('Open trades:', trades);
+}
+
+// Run the example
+main().catch(console.error);