@decibeltrade/sdk 0.1.1

package/sdk_reference.md

@@ -0,0 +1,876 @@
+# Decibel TypeScript SDK Reference
+
+## Overview
+
+The Decibel TypeScript SDK provides an interface for interacting with Decibel Smart Conracts on Aptos. The SDK is split into two main components:
+
+- **Read operations** (`DecibelReadDex`) - For querying market data, positions, orders, and account information
+- **Write operations** (`DecibelWriteDex`) - For executing trades, managing orders, and account operations
+
+## Installation
+
+```typescript
+import { DecibelReadDex, DecibelWriteDex, NETNA_CONFIG } from "@decibeltrade/sdk";
+```
+
+## Quick Start
+
+### Read Operations
+
+```typescript
+import { DecibelReadDex, NETNA_CONFIG } from "@decibeltrade/sdk";
+
+// Initialize the read client
+const readDex = new DecibelReadDex(NETNA_CONFIG, {
+  nodeApiKey: "your-api-key", // optional
+  onWsError: (error) => console.error("WebSocket error:", error), // optional
+});
+
+// Get all available markets
+const markets = await readDex.markets.getAll();
+
+// Get account overview
+const accountOverview = await readDex.accountOverview.getByAddr("0x123...");
+```
+
+### Write Operations
+
+```typescript
+import { DecibelWriteDex, NETNA_CONFIG, Account } from "@decibeltrade/sdk";
+
+// Initialize with your account
+const account = Account.fromPrivateKey({ privateKey: "your-private-key" });
+const writeDex = new DecibelWriteDex(NETNA_CONFIG, account);
+
+// Place an order
+const result = await writeDex.placeOrder({
+  marketName: "BTC-USD",
+  price: 45000,
+  size: 1.5,
+  isBuy: true,
+  timeInForce: TimeInForce.GoodTillCanceled,
+  isReduceOnly: false,
+});
+```
+
+## Configuration
+
+### Predefined Configurations
+
+The SDK provides several predefined network configurations:
+
+```typescript
+import { NETNA_CONFIG, LOCAL_CONFIG, DOCKER_CONFIG } from "@decibeltrade/sdk";
+
+// Netna (Staging)
+const readDex = new DecibelReadDex(NETNA_CONFIG);
+
+// Local development
+const localReadDex = new DecibelReadDex(LOCAL_CONFIG);
+
+// Docker environment
+const dockerReadDex = new DecibelReadDex(DOCKER_CONFIG);
+```
+
+### Example Configuration File
+
+Here's an example of how to set up your configuration constants:
+
+```typescript path=null start=null
+// constants.ts
+import { AccountAddress, createObjectAddress, Network } from "@aptos-labs/ts-sdk";
+
+export interface DecibelConfig {
+  network: Network;
+  fullnodeUrl: string;
+  tradingHttpUrl: string;
+  tradingWsUrl: string;
+  gasStationUrl: string;
+  deployment: Deployment;
+}
+
+export interface Deployment {
+  package: string;
+  usdc: string;
+  testc: string;
+  perpEngineGlobal: string;
+}
+
+// Utility functions to generate addresses
+export function getUsdcAddress(publisherAddr: string) {
+  return createObjectAddress(
+    AccountAddress.fromString(publisherAddr),
+    new TextEncoder().encode("USDC"),
+  );
+}
+
+export function getTestcAddress(publisherAddr: string) {
+  return createObjectAddress(
+    AccountAddress.fromString(publisherAddr),
+    new TextEncoder().encode("TESTC"),
+  );
+}
+
+export function getPerpEngineGlobalAddress(publisherAddr: string) {
+  return createObjectAddress(
+    AccountAddress.fromString(publisherAddr),
+    new TextEncoder().encode("GlobalPerpEngine"),
+  );
+}
+
+// Network configurations
+const NETNA_PACKAGE = "0xb8a5788314451ce4d2fbbad32e1bad88d4184b73943b7fe5166eab93cf1a5a95";
+
+export const NETNA_DEPLOYMENT: Deployment = {
+  package: NETNA_PACKAGE,
+  usdc: getUsdcAddress(NETNA_PACKAGE).toString(),
+  testc: getTestcAddress(NETNA_PACKAGE).toString(),
+  perpEngineGlobal: getPerpEngineGlobalAddress(NETNA_PACKAGE).toString(),
+};
+
+export const NETNA_CONFIG: DecibelConfig = {
+  network: Network.CUSTOM,
+  fullnodeUrl: "https://api.netna.staging.aptoslabs.com/v1",
+  tradingHttpUrl: "https://api.netna.aptoslabs.com/decibel",
+  tradingWsUrl: "wss://api.netna.aptoslabs.com/decibel/ws",
+  gasStationUrl: "https://fee-payer-dev-netna-us-central1-410192433417.us-central1.run.app",
+  deployment: NETNA_DEPLOYMENT,
+};
+
+export const LOCAL_CONFIG: DecibelConfig = {
+  network: Network.CUSTOM,
+  fullnodeUrl: "http://localhost:8080/v1",
+  tradingHttpUrl: "http://localhost:8084",
+  tradingWsUrl: "ws://localhost:8083",
+  gasStationUrl: "http://localhost:8085",
+  deployment: NETNA_DEPLOYMENT,
+};
+
+export const DOCKER_CONFIG: DecibelConfig = {
+  network: Network.CUSTOM,
+  fullnodeUrl: "http://tradenet:8080/v1",
+  tradingHttpUrl: "http://trading-api-http:8080",
+  // nosemgrep: javascript.lang.security.detect-insecure-websocket.detect-insecure-websocket
+  tradingWsUrl: "ws://trading-api-ws:8080",
+  gasStationUrl: "http://fee-payer:8080",
+  deployment: NETNA_DEPLOYMENT,
+};
+
+export const NAMED_CONFIGS: Record<string, DecibelConfig | undefined> = {
+  netna: NETNA_CONFIG,
+  local: LOCAL_CONFIG,
+  docker: DOCKER_CONFIG,
+};
+```
+
+### Custom Configuration
+
+You can also create custom configurations for other environments:
+
+```typescript
+import { DecibelConfig, Network } from "@decibeltrade/sdk";
+
+const customConfig: DecibelConfig = {
+  network: Network.CUSTOM,
+  fullnodeUrl: "https://your-fullnode-url.com/v1",
+  tradingHttpUrl: "https://your-trading-api.com",
+  tradingWsUrl: "wss://your-trading-ws.com",
+  gasStationUrl: "https://your-fee-payer.com",
+  deployment: {
+    package: "0x...",
+    usdc: "0x...",
+    testc: "0x...",
+    perpEngineGlobal: "0x...",
+  },
+};
+```
+
+## Read Operations API
+
+### DecibelReadDex
+
+The main read client providing access to all market data and account information.
+
+#### Constructor
+
+```typescript
+new DecibelReadDex(config: DecibelConfig, opts?: {
+  nodeApiKey?: string;
+  onWsError?: (error: ErrorEvent) => void;
+})
+```
+
+#### Global Methods
+
+```typescript
+// Get global perpetual engine state
+await readDex.globalPerpEngineState();
+
+// Get collateral balance decimals
+await readDex.collateralBalanceDecimals();
+
+// Get USDC decimals (cached)
+await readDex.usdcDecimals();
+
+// Get USDC balance for an address
+await readDex.usdcBalance("0x123...");
+
+// Get account balance
+await readDex.accountBalance("0x123...");
+
+// Get position size
+await readDex.positionSize("0x123...", "metadata_address");
+
+// Get crossed position
+await readDex.getCrossedPosition("0x123...");
+```
+
+### Markets
+
+Access market information and configuration.
+
+```typescript
+// Get all available markets
+const markets = await readDex.markets.getAll();
+
+// Get specific market by name
+const market = await readDex.markets.getByName("BTC-USD");
+
+// List all market addresses
+const addresses = await readDex.markets.listMarketAddresses();
+
+// Get market name by address
+const name = await readDex.markets.marketNameByAddress("0x123...");
+```
+
+### Account Overview
+
+Get comprehensive account information including balances and positions.
+
+```typescript
+// Get account overview
+const overview = await readDex.accountOverview.getByAddr("subaccount_address", "30d"); // volume_window = "30d"
+
+// Subscribe to real-time account updates
+const unsubscribe = readDex.accountOverview.subscribeByAddr("subaccount_address", (data) =>
+  console.log("Account update:", data),
+);
+
+// Later, unsubscribe
+unsubscribe();
+```
+
+### User Positions
+
+Query user positions across markets.
+
+```typescript
+// Get all positions for a user
+const positions = await readDex.userPositions.getByAddr({
+  subAddr: "subaccount_address",
+  includeDeleted: false,
+  limit: 10,
+});
+
+// Get positions for specific market
+const marketPositions = await readDex.userPositions.getByAddr({
+  subAddr: "subaccount_address",
+  marketAddr: "market_address",
+  limit: 10,
+});
+
+// Subscribe to position updates
+const unsubscribe = readDex.userPositions.subscribeByAddr("subaccount_address", (data) =>
+  console.log("Position update:", data),
+);
+```
+
+### User Orders
+
+Query open orders and order history.
+
+#### Open Orders
+
+```typescript
+// Get open orders
+const openOrders = await readDex.userOpenOrders.getByAddr("subaccount_address");
+
+// Subscribe to open orders updates
+const unsubscribe = readDex.userOpenOrders.subscribeByAddr("subaccount_address", (data) =>
+  console.log("Orders update:", data),
+);
+```
+
+#### Order History
+
+```typescript
+// Get order history
+const orderHistory = await readDex.userOrderHistory.getByAddr({
+  subAddr: "subaccount_address",
+  marketAddr: "market_address", // optional
+  limit: 50,
+});
+
+// Subscribe to order history updates
+const unsubscribe = readDex.userOrderHistory.subscribeByAddr("subaccount_address", (data) =>
+  console.log("Order history update:", data),
+);
+```
+
+### Market Data
+
+#### Market Depth (Order Book)
+
+```typescript
+// Get market depth
+const depth = await readDex.marketDepth.getByName("BTC-USD", 100); // limit = 100
+
+// Subscribe to depth updates
+const unsubscribe = readDex.marketDepth.subscribeByName("BTC-USD", (data) =>
+  console.log("Depth update:", data),
+);
+
+// Reset subscription (clear cached data)
+readDex.marketDepth.resetSubscriptionByName("BTC-USD");
+```
+
+#### Market Prices
+
+```typescript
+// Get current prices
+const prices = await readDex.marketPrices.getByName("BTC-USD");
+
+// Subscribe to price updates
+const unsubscribe = readDex.marketPrices.subscribeByName("BTC-USD", (data) =>
+  console.log("Price update:", data),
+);
+```
+
+#### Market Trades
+
+```typescript
+// Get recent trades
+const trades = await readDex.marketTrades.getByName("BTC-USD", 50); // limit = 50
+
+// Subscribe to trade updates
+const unsubscribe = readDex.marketTrades.subscribeByName("BTC-USD", (data) =>
+  console.log("Trade update:", data),
+);
+```
+
+#### Candlesticks
+
+```typescript
+import { CandlestickInterval } from "@decibeltrade/sdk";
+
+// Get historical candlestick data
+const candlesticks = await readDex.candlesticks.getByName(
+  "BTC-USD",
+  CandlestickInterval.MINUTE_1,
+  startTimestamp,
+  endTimestamp,
+);
+
+// Subscribe to candlestick updates
+const unsubscribe = readDex.candlesticks.subscribeByName(
+  "BTC-USD",
+  CandlestickInterval.MINUTE_1,
+  (data) => console.log("Candlestick update:", data),
+);
+```
+
+### Market Contexts
+
+Get additional market metadata and context.
+
+```typescript
+// Get market contexts
+const contexts = await readDex.marketContexts.getAll();
+
+// Subscribe to market context updates
+const unsubscribe = readDex.marketContexts.subscribeAll((data) =>
+  console.log("Market contexts update:", data),
+);
+```
+
+### User Trade History
+
+Query historical trade data for a user.
+
+```typescript
+// Get trade history
+const trades = await readDex.userTradeHistory.getByAddr({
+  subAddr: "subaccount_address",
+  marketAddr: "market_address", // optional
+  limit: 100,
+});
+
+// Subscribe to trade history updates
+const unsubscribe = readDex.userTradeHistory.subscribeByAddr("subaccount_address", (data) =>
+  console.log("Trade history update:", data),
+);
+```
+
+### User Funding History
+
+Query funding payment history.
+
+```typescript
+// Get funding history
+const funding = await readDex.userFundingHistory.getByAddr({
+  subAddr: "subaccount_address",
+  marketAddr: "market_address", // optional
+  limit: 50,
+});
+
+// Subscribe to funding history updates
+const unsubscribe = readDex.userFundingHistory.subscribeByAddr("subaccount_address", (data) =>
+  console.log("Funding history update:", data),
+);
+```
+
+## Write Operations API
+
+### DecibelWriteDex
+
+The main write client for executing trades and managing account operations.
+
+#### Constructor
+
+```typescript
+import { Account } from "@aptos-labs/ts-sdk";
+
+const account = Account.fromPrivateKey({ privateKey: "your-private-key" });
+const writeDex = new DecibelWriteDex(config, account, opts?: {
+  nodeApiKey?: string;
+  sponsorAccount?: Account;
+  maxGasAmount?: number;
+  gasUnitPrice?: number;
+});
+```
+
+### Account Management
+
+#### Subaccount Operations
+
+```typescript
+// Create a new subaccount
+await writeDex.createSubaccount();
+
+// Deposit collateral to primary subaccount
+await writeDex.deposit(1000000); // amount in smallest unit
+
+// Deposit to specific subaccount
+await writeDex.deposit(1000000, "subaccount_address");
+
+// Withdraw from subaccount
+await writeDex.withdraw(500000, "subaccount_address");
+```
+
+#### Trading Delegation
+
+```typescript
+// Delegate trading permissions
+await writeDex.delegateTradingTo({
+  subaccountAddr: "your_subaccount",
+  accountToDelegateTo: "delegate_account_address",
+});
+
+// Revoke delegation
+await writeDex.revokeDelegation({
+  subaccountAddr: "your_subaccount",
+  accountToRevoke: "delegate_account_address",
+});
+```
+
+#### Market Configuration
+
+```typescript
+// Configure user settings for a market
+await writeDx.configureUserSettingsForMarket({
+  marketAddr: "market_address",
+  subaccountAddr: "subaccount_address",
+  isCross: true, // cross-margin mode
+  userLeverage: 1000, // 10x leverage (basis points)
+});
+```
+
+### Order Management
+
+#### Place Orders
+
+```typescript
+import { TimeInForce } from "@decibeltrade/sdk";
+
+// Place a limit order
+const result = await writeDex.placeOrder({
+  marketName: "BTC-USD",
+  price: 45000,
+  size: 1.5,
+  isBuy: true,
+  timeInForce: TimeInForce.GoodTillCanceled,
+  isReduceOnly: false,
+  clientOrderId: "12345", // optional
+  subaccountAddr: "subaccount_address", // optional
+});
+
+// Place a post-only order
+await writeDex.placeOrder({
+  marketName: "ETH-USD",
+  price: 3000,
+  size: 2.0,
+  isBuy: false,
+  timeInForce: TimeInForce.PostOnly,
+  isReduceOnly: false,
+});
+
+// Place an IOC (Immediate or Cancel) order
+await writeDex.placeOrder({
+  marketName: "SOL-USD",
+  price: 100,
+  size: 10,
+  isBuy: true,
+  timeInForce: TimeInForce.ImmediateOrCancel,
+  isReduceOnly: true,
+});
+```
+
+#### Advanced Order Types
+
+```typescript
+// Place order with stop-loss and take-profit
+await writeDex.placeOrder({
+  marketName: "BTC-USD",
+  price: 45000,
+  size: 1.0,
+  isBuy: true,
+  timeInForce: TimeInForce.GoodTillCanceled,
+  isReduceOnly: false,
+  stopPrice: 44000, // stop-loss trigger
+  tpTriggerPrice: 46000, // take-profit trigger
+  tpLimitPrice: 45900, // take-profit limit price
+  slTriggerPrice: 44000, // stop-loss trigger
+  slLimitPrice: 44100, // stop-loss limit price
+});
+
+// Place order with builder fee
+await writeDex.placeOrder({
+  marketName: "BTC-USD",
+  price: 45000,
+  size: 1.0,
+  isBuy: true,
+  timeInForce: TimeInForce.GoodTillCanceled,
+  isReduceOnly: false,
+  builderAddr: "builder_account_address",
+  builderFee: 100, // fee in basis points
+});
+```
+
+#### TWAP Orders
+
+```typescript
+// Place a Time-Weighted Average Price order
+await writeDex.placeTwapOrder({
+  marketName: "BTC-USD",
+  size: 10.0,
+  isBuy: true,
+  isReduceOnly: false,
+  twapFrequencySeconds: 60, // execute every 60 seconds
+  twapDurationSeconds: 3600, // over 1 hour period
+  subaccountAddr: "subaccount_address", // optional
+});
+```
+
+#### Cancel Orders
+
+```typescript
+// Cancel order by ID and market name
+await writeDex.cancelOrder({
+  orderId: 12345,
+  marketName: "BTC-USD",
+  subaccountAddr: "subaccount_address", // optional
+});
+
+// Cancel order by ID and market address
+await writeDx.cancelOrder({
+  orderId: 12345,
+  marketAddr: "market_address",
+  subaccountAddr: "subaccount_address", // optional
+});
+
+// Cancel order by client order ID
+await writeDex.cancelClientOrder({
+  clientOrderId: "54321",
+  marketName: "BTC-USD",
+  subaccountAddr: "subaccount_address", // optional
+});
+```
+
+### Position Management
+
+#### Take-Profit / Stop-Loss Orders
+
+```typescript
+// Place TP/SL order for existing position
+await writeDx.placeTpSlOrderForPosition({
+  marketAddr: "market_address",
+  tpTriggerPrice: 46000,
+  tpLimitPrice: 45900,
+  tpSize: 0.5, // partial position size
+  slTriggerPrice: 44000,
+  slLimitPrice: 44100,
+  slSize: 1.0, // full position size
+  subaccountAddr: "subaccount_address", // optional
+});
+
+// Update existing TP/SL order
+await writeDex.updateTpSlOrderForPosition({
+  marketAddr: "market_address",
+  prevOrderId: "previous_order_id",
+  tpTriggerPrice: 47000, // new TP trigger
+  tpLimitPrice: 46900,
+  tpSize: 0.75,
+  // ... other parameters
+});
+
+// Cancel TP/SL order
+await writeDex.cancelTpSlOrderForPosition({
+  marketName: "BTC-USD",
+  orderId: 12345,
+  subaccountAddr: "subaccount_address", // optional
+});
+```
+
+### Order Status Tracking
+
+The write client includes an order status client for tracking order execution:
+
+```typescript
+// Access order status client
+const orderStatus = writeDex.orderStatusClient;
+
+// Use order status methods (implementation depends on OrderStatusClient)
+```
+
+### Session Accounts
+
+You can override the default account for specific transactions using session accounts:
+
+```typescript
+import { Account } from "@aptos-labs/ts-sdk";
+
+const sessionAccount = Account.generate();
+
+// Use session account for this transaction
+await writeDex.placeOrder({
+  marketName: "BTC-USD",
+  price: 45000,
+  size: 1.0,
+  isBuy: true,
+  timeInForce: TimeInForce.GoodTillCanceled,
+  isReduceOnly: false,
+  accountOverride: sessionAccount,
+});
+```
+
+### Error Handling
+
+All write operations return transaction results. For order placement, you get a structured result:
+
+```typescript
+interface PlaceOrderResult {
+  success: boolean;
+  orderId?: string;
+  transactionHash: string;
+  error?: string;
+}
+
+const result = await writeDex.placeOrder({
+  // ... order parameters
+});
+
+if (result.success) {
+  console.log("Order placed successfully:", result.orderId);
+  console.log("Transaction:", result.transactionHash);
+} else {
+  console.error("Order failed:", result.error);
+}
+```
+
+## Constants and Enums
+
+### Time in Force
+
+```typescript
+export const TimeInForce = {
+  GoodTillCanceled: 0,
+  PostOnly: 1,
+  ImmediateOrCancel: 2,
+} as const;
+```
+
+### Candlestick Intervals
+
+```typescript
+export enum CandlestickInterval {
+  MINUTE_1 = "1m",
+  MINUTE_5 = "5m",
+  MINUTE_15 = "15m",
+  HOUR_1 = "1h",
+  HOUR_4 = "4h",
+  DAY_1 = "1d",
+}
+```
+
+## Utilities
+
+### Address Utilities
+
+```typescript
+import { getPrimarySubaccountAddr, getMarketAddr } from "@decibeltrade/sdk";
+
+// Get primary subaccount address for an account
+const subaccountAddr = getPrimarySubaccountAddr("account_address");
+
+// Get market address from name
+const marketAddr = getMarketAddr("BTC-USD", "perp_engine_global_address");
+```
+
+## WebSocket Subscriptions
+
+All read operations that support real-time updates return an unsubscribe function:
+
+```typescript
+// Subscribe to multiple streams
+const unsubscribeDepth = readDex.marketDepth.subscribeByName("BTC-USD", handleDepth);
+const unsubscribePrices = readDex.marketPrices.subscribeByName("BTC-USD", handlePrices);
+const unsubscribeOrders = readDex.userOpenOrders.subscribeByAddr("subaccount", handleOrders);
+
+// Clean up subscriptions
+function cleanup() {
+  unsubscribeDepth();
+  unsubscribePrices();
+  unsubscribeOrders();
+}
+
+// Handle errors
+const readDex = new DecibelReadDex(NETNA_CONFIG, {
+  onWsError: (error) => {
+    console.error("WebSocket error:", error);
+    // Implement reconnection logic
+  },
+});
+```
+
+## TypeScript Types
+
+The SDK is fully typed with Zod schemas for runtime validation. Import types for better development experience:
+
+```typescript
+import type {
+  DecibelConfig,
+  PerpMarket,
+  UserPosition,
+  MarketDepth,
+  CandlestickData,
+  AccountOverview,
+  PlaceOrderResult,
+} from "@decibeltrade/sdk";
+```
+
+## Best Practices
+
+1. **Connection Management**: Reuse SDK instances where possible to maintain WebSocket connections.
+
+2. **Error Handling**: Always wrap SDK calls in try-catch blocks and handle errors appropriately.
+
+3. **Subscription Cleanup**: Always call unsubscribe functions to prevent memory leaks.
+
+4. **Rate Limiting**: Be mindful of API rate limits when making frequent requests.
+
+5. **Account Security**: Never expose private keys in client-side code. Use environment variables or secure key management.
+
+6. **Precision**: Be careful with number precision for prices and sizes. The SDK handles decimal precision internally.
+
+## Examples
+
+### Complete Trading Bot Example
+
+```typescript
+import {
+  DecibelReadDex,
+  DecibelWriteDex,
+  NETNA_CONFIG,
+  TimeInForce,
+  Account,
+} from "@decibeltrade/sdk";
+
+class TradingBot {
+  private readDex: DecibelReadDex;
+  private writeDex: DecibelWriteDex;
+  private subaccountAddr: string;
+
+  constructor(privateKey: string, subaccountAddr: string) {
+    this.readDex = new DecibelReadDex(NETNA_CONFIG);
+
+    const account = Account.fromPrivateKey({ privateKey });
+    this.writeDex = new DecibelWriteDex(NETNA_CONFIG, account);
+    this.subaccountAddr = subaccountAddr;
+  }
+
+  async start() {
+    // Subscribe to market data
+    this.readDx.marketPrices.subscribeByName("BTC-USD", this.handlePriceUpdate.bind(this));
+    this.readDex.marketDepth.subscribeByName("BTC-USD", 1, this.handleDepthUpdate.bind(this));
+
+    // Subscribe to account updates
+    this.readDex.userPositions.subscribeByAddr(
+      this.subaccountAddr,
+      this.handlePositionUpdate.bind(this),
+    );
+  }
+
+  private async handlePriceUpdate(priceData: any) {
+    // Implement your trading logic here
+    console.log("Price update:", priceData);
+  }
+
+  private async handleDepthUpdate(depthData: any) {
+    // Analyze order book for trading opportunities
+    console.log("Depth update:", depthData);
+  }
+
+  private async handlePositionUpdate(positionData: any) {
+    // Monitor positions and manage risk
+    console.log("Position update:", positionData);
+  }
+
+  async placeMarketBuyOrder(size: number) {
+    try {
+      const result = await this.writeDex.placeOrder({
+        marketName: "BTC-USD",
+        price: 0, // Market order (implementation may vary)
+        size,
+        isBuy: true,
+        timeInForce: TimeInForce.ImmediateOrCancel,
+        isReduceOnly: false,
+        subaccountAddr: this.subaccountAddr,
+      });
+
+      if (result.success) {
+        console.log(`Market buy order placed: ${result.orderId}`);
+      } else {
+        console.error(`Order failed: ${result.error}`);
+      }
+    } catch (error) {
+      console.error("Error placing order:", error);
+    }
+  }
+}
+
+// Usage
+const bot = new TradingBot("your-private-key", "your-subaccount-address");
+bot.start();
+```
+
+This SDK provides comprehensive access to the Decibel derivatives exchange, enabling both simple trading operations and complex algorithmic trading strategies.