Execution & Algorithms

import { Client, Config, NativeVenueConfig, CcxtConfig } from '@liquidityio/trading';

const config = new Config()
  .withNative('liquidity', NativeVenueConfig.liquidDex('https://api.liquidity.io/v1'))
  .withCcxt('binance', CcxtConfig.create('binance').withCredentials('key', 'secret'))
  .withCcxt('okx', CcxtConfig.create('okx').withCredentials('key', 'secret'))
  .withVenuePriority(['liquidity', 'binance', 'okx'])
  .withSmartRouting(true);

const client = new Client(config);
await client.connect();

// This order is automatically routed to the best venue
const order = await client.buy('BTC-USDC', '1.0');
console.log(`Routed to ${order.venue} at ${order.averagePrice}`);

// Force execution on Binance
const order = await client.buy('BTC-USDC', '1.0', 'binance');

// Force execution on the Liquidity.io ATS
const atsOrder = await client.limitBuy('AAPL', 100, '248.50', 'liquidity');

from lx_trading import Client, Config
from lx_trading.config import NativeVenueConfig, CcxtConfig

config = Config()
config.with_native("liquidity", NativeVenueConfig.liquid_dex("https://api.liquidity.io/v1"))
config.with_ccxt("binance", CcxtConfig.create("binance").with_credentials("key", "secret"))
config.smart_routing = True

client = Client(config)
await client.connect()

# Smart-routed order
order = await client.buy("BTC-USDC", Decimal("1.0"))
print(f"Routed to {order.venue} at {order.average_price}")

# Explicit venue
order = await client.buy("BTC-USDC", Decimal("1.0"), venue="binance")

import { TwapExecutor, Side } from '@liquidityio/trading';
import { Decimal } from 'decimal.js';

const twap = new TwapExecutor(
  client,
  'BTC-USDC',              // symbol
  Side.BUY,                // side
  new Decimal('10'),       // total quantity: 10 BTC
  3600,                    // duration: 1 hour
  12,                      // 12 slices (one every 5 minutes)
);

const orders = await twap.execute();
console.log(`Executed ${orders.length} slices`);
for (const o of orders) {
  console.log(`  ${o.orderId}: ${o.filledQuantity} @ ${o.averagePrice}`);
}

from lx_trading.execution import TwapExecutor
from lx_trading.types import Side
from decimal import Decimal

twap = TwapExecutor(
    client=client,
    symbol="BTC-USDC",
    side=Side.BUY,
    total_quantity=Decimal("10"),
    duration_seconds=3600,
    num_slices=12,
)

orders = await twap.execute()
for o in orders:
    print(f"  {o.order_id}: {o.filled_quantity} @ {o.average_price}")

import { VwapExecutor, Side } from '@liquidityio/trading';

const vwap = new VwapExecutor(
  client,
  'BTC-USDC',              // symbol
  Side.BUY,                // side
  new Decimal('10'),       // total: 10 BTC
  new Decimal('0.10'),     // 10% participation rate
  7200,                    // max 2 hours
);

const orders = await vwap.execute();
const totalFilled = orders.reduce(
  (sum, o) => sum.plus(o.filledQuantity),
  new Decimal(0),
);
console.log(`VWAP filled ${totalFilled} BTC across ${orders.length} slices`);

from lx_trading.execution import VwapExecutor

vwap = VwapExecutor(
    client=client,
    symbol="BTC-USDC",
    side=Side.BUY,
    total_quantity=Decimal("10"),
    participation_rate=Decimal("0.10"),
    max_duration_seconds=7200,
)

orders = await vwap.execute()
total_filled = sum(o.filled_quantity for o in orders)
print(f"VWAP filled {total_filled} BTC in {len(orders)} slices")

import { IcebergExecutor, Side } from '@liquidityio/trading';

const iceberg = new IcebergExecutor(
  client,
  'BTC-USDC',              // symbol
  Side.BUY,                // side
  new Decimal('100'),      // total: 100 BTC (hidden)
  new Decimal('5'),        // visible: 5 BTC at a time
  new Decimal('83000'),    // limit price
  'liquidity',             // venue (optional)
);

const orders = await iceberg.execute();
console.log(`Iceberg completed: ${orders.length} slices filled`);

from lx_trading.execution import IcebergExecutor

iceberg = IcebergExecutor(
    client=client,
    symbol="BTC-USDC",
    side=Side.BUY,
    total_quantity=Decimal("100"),
    visible_quantity=Decimal("5"),
    price=Decimal("83000"),
    venue="liquidity",
)

orders = await iceberg.execute()

import { SniperExecutor, Side } from '@liquidityio/trading';

const sniper = new SniperExecutor(
  client,
  'BTC-USDC',              // symbol
  Side.BUY,                // side
  new Decimal('1'),        // quantity: 1 BTC
  new Decimal('80000'),    // trigger when ask <= 80000
  300,                     // timeout: 5 minutes
);

const order = await sniper.execute();
if (order) {
  console.log(`Sniped at ${order.averagePrice}`);
} else {
  console.log('Timeout reached, price target not hit');
}

from lx_trading.execution import SniperExecutor

sniper = SniperExecutor(
    client=client,
    symbol="BTC-USDC",
    side=Side.BUY,
    quantity=Decimal("1"),
    target_price=Decimal("80000"),
    timeout_seconds=300,
)

order = await sniper.execute()
if order:
    print(f"Sniped at {order.average_price}")
else:
    print("Timeout -- target not reached")

import { PovExecutor, Side } from '@liquidityio/trading';

const pov = new PovExecutor(
  client,
  'BTC-USDC',              // symbol
  Side.SELL,               // side
  new Decimal('50'),       // total: 50 BTC
  new Decimal('0.05'),     // 5% of market volume
  14400,                   // max 4 hours
);

const orders = await pov.execute();
console.log(`POV completed: ${orders.length} slices`);

import { DcaExecutor, Side } from '@liquidityio/trading';

const dca = new DcaExecutor(
  client,
  'BTC-USDC',              // symbol
  Side.BUY,                // side
  new Decimal('1000'),     // $1000 per interval
  3600000,                 // every 1 hour
  24,                      // 24 intervals (1 day)
  'liquidity',             // venue (optional)
);

const orders = await dca.execute();
const totalSpent = orders.reduce(
  (sum, o) => sum.plus(o.filledQuantity.mul(o.averagePrice ?? 0)),
  new Decimal(0),
);
console.log(`DCA invested $${totalSpent} across ${orders.length} buys`);

from lx_trading.execution import DcaExecutor

dca = DcaExecutor(
    client=client,
    symbol="BTC-USDC",
    side=Side.BUY,
    amount_per_interval=Decimal("1000"),
    interval_ms=3600000,
    num_intervals=24,
    venue="liquidity",
)

orders = await dca.execute()

import { RiskManager, RiskError } from '@liquidityio/trading';
import { Decimal } from 'decimal.js';

const risk = new RiskManager({
  enabled: true,
  maxPositionSize: new Decimal('100'),    // Max 100 units of any asset
  maxOrderSize: new Decimal('10'),        // Max 10 units per order
  maxDailyLoss: new Decimal('5000'),      // $5000 daily loss limit
  maxOpenOrders: 50,                       // Max 50 open orders per symbol
  killSwitchEnabled: true,                 // Auto-halt on loss breach
  positionLimits: new Map([
    ['BTC', new Decimal('10')],           // Max 10 BTC position
    ['ETH', new Decimal('100')],          // Max 100 ETH position
  ]),
});

// Validate before placing an order
try {
  risk.validateOrder(orderRequest);
  const order = await client.placeOrder(orderRequest);
  risk.orderOpened(order.symbol);
} catch (e) {
  if (e instanceof RiskError) {
    console.error(`Risk check failed: ${e.message}`);
    // Do not place the order
  }
}

// Update after fills
risk.updatePosition('BTC', new Decimal('1'), Side.BUY);
risk.updatePnl(new Decimal('-250'));

// Check state
console.log(`BTC position: ${risk.position('BTC')}`);
console.log(`Daily PnL: ${risk.getDailyPnl()}`);
console.log(`Kill switch active: ${risk.isKilled}`);

// Reset daily PnL at start of trading day
risk.resetDailyPnl();

from lx_trading import RiskManager, RiskError
from lx_trading.config import RiskConfig
from decimal import Decimal

risk = RiskManager(RiskConfig(
    enabled=True,
    max_position_size=Decimal("100"),
    max_order_size=Decimal("10"),
    max_daily_loss=Decimal("5000"),
    max_open_orders=50,
    kill_switch_enabled=True,
    position_limits={"BTC": Decimal("10"), "ETH": Decimal("100")},
))

try:
    risk.validate_order(order_request)
    order = await client.place_order(order_request)
    risk.order_opened(order.symbol)
except RiskError as e:
    print(f"Risk check failed: {e}")

risk.reset();          // Deactivate kill switch
risk.resetDailyPnl();  // Reset daily PnL counter

import { orderIsOpen, orderIsDone, orderFillPercent } from '@liquidityio/trading';

const order = await client.limitBuy('BTC-USDC', '1.0', '83000');

// Check status
console.log(`Open: ${orderIsOpen(order)}`);
console.log(`Done: ${orderIsDone(order)}`);
console.log(`Fill %: ${orderFillPercent(order)}%`);
console.log(`Filled: ${order.filledQuantity} / ${order.quantity}`);
console.log(`Remaining: ${order.remainingQuantity}`);
console.log(`Avg price: ${order.averagePrice}`);
console.log(`Fees:`, order.fees);

interface Trade {
  tradeId: string;        // Unique trade ID
  orderId: string;        // Parent order ID
  symbol: string;         // Trading pair
  venue: string;          // Execution venue
  side: Side;             // Buy or sell
  price: Decimal;         // Execution price
  quantity: Decimal;       // Fill quantity
  fee: Fee;               // Fee charged
  timestamp: number;      // Unix timestamp
  isMaker: boolean;       // True if maker, false if taker
}

const book = await client.orderbook('BTC-USDC');

// Expected VWAP for buying 1 BTC based on current book
const expectedVwap = book.vwapBuy(new Decimal('1'));

// Compare against actual execution
const actualPrice = order.averagePrice;
const slippage = actualPrice?.minus(expectedVwap ?? 0);
console.log(`Expected VWAP: ${expectedVwap}`);
console.log(`Actual price: ${actualPrice}`);
console.log(`Slippage: ${slippage}`);

// Aggregated balances across all venues
const balances = await client.balances();
for (const b of balances) {
  console.log(`${b.asset}: ${b.totalFree} free, ${b.totalLocked} locked`);
  for (const v of b.byVenue) {
    console.log(`  ${v.venue}: ${v.free} free, ${v.locked} locked`);
  }
}

// Single asset balance on a specific venue
const btcBalance = await client.balance('BTC', 'liquidity');
console.log(`BTC on Liquidity.io: ${btcBalance.free} free`);

[general]
log_level = "info"
timeout_ms = 30000
smart_routing = true
venue_priority = ["liquidity", "binance"]
min_improvement_bps = 5

[risk]
enabled = true
max_position_size = 100
max_order_size = 10
max_daily_loss = 5000
max_open_orders = 50
kill_switch_enabled = true

[risk.position_limits]
BTC = 10
ETH = 100

[native.liquidity]
venue_type = "dex"
api_url = "https://api.liquidity.io/v1"
ws_url = "wss://api.liquidity.io/ws"
api_key = "your-api-key"
api_secret = "your-api-secret"
network = "mainnet"
chain_id = 96369
streaming = true

[ccxt.binance]
exchange_id = "binance"
api_key = "your-binance-key"
api_secret = "your-binance-secret"
sandbox = false
rate_limit = true

import { Config } from '@liquidityio/trading';

const config = Config.fromObject(require('./config.toml'));
const client = new Client(config);

config = Config.from_file("config.toml")
client = Client(config)