e169c492aa
- Introduced DexExample.swift demonstrating decentralized exchange operations including spot trading, perpetual futures, liquidity provision, order book management, and portfolio tracking. - Added IbcExample.swift showcasing inter-blockchain communication operations such as cross-chain transfers, channel management, packet handling, and relayer operations. - Created ZkExample.swift illustrating zero-knowledge proof operations including circuit compilation, proof generation and verification, and trusted setup ceremonies.
351 lines
11 KiB
Kotlin
351 lines
11 KiB
Kotlin
package io.synor.examples
|
|
|
|
import io.synor.dex.*
|
|
import io.synor.dex.types.*
|
|
import kotlinx.coroutines.runBlocking
|
|
import java.math.BigDecimal
|
|
|
|
/**
|
|
* Synor DEX SDK Examples for Kotlin
|
|
*
|
|
* Demonstrates decentralized exchange operations:
|
|
* - Spot trading (limit/market orders)
|
|
* - Perpetual futures trading
|
|
* - Liquidity provision (AMM pools)
|
|
* - Order book management
|
|
* - Portfolio tracking
|
|
*/
|
|
fun main() = runBlocking {
|
|
// Initialize client
|
|
val config = DexConfig(
|
|
apiKey = System.getenv("SYNOR_API_KEY") ?: "your-api-key",
|
|
endpoint = "https://dex.synor.io/v1",
|
|
timeout = 30_000,
|
|
retries = 3,
|
|
debug = false,
|
|
defaultMarket = "SYN-USDC"
|
|
)
|
|
|
|
val dex = SynorDex(config)
|
|
|
|
try {
|
|
// Check service health
|
|
val healthy = dex.healthCheck()
|
|
println("Service healthy: $healthy\n")
|
|
|
|
// Run examples
|
|
marketsExample(dex)
|
|
spotTradingExample(dex)
|
|
perpsTradingExample(dex)
|
|
liquidityExample(dex)
|
|
orderbookExample(dex)
|
|
portfolioExample(dex)
|
|
} finally {
|
|
dex.close()
|
|
}
|
|
}
|
|
|
|
suspend fun marketsExample(dex: SynorDex) {
|
|
println("=== Markets ===")
|
|
|
|
// Get all markets
|
|
val markets = dex.markets.list()
|
|
println("Available markets: ${markets.size}")
|
|
|
|
markets.take(5).forEach { market ->
|
|
println("\n ${market.symbol}:")
|
|
println(" Base: ${market.baseAsset}, Quote: ${market.quoteAsset}")
|
|
println(" Price: ${market.lastPrice}")
|
|
println(" 24h Volume: ${market.volume24h}")
|
|
println(" 24h Change: ${market.change24h}%")
|
|
println(" Status: ${market.status}")
|
|
}
|
|
|
|
// Get specific market
|
|
val market = dex.markets.get("SYN-USDC")
|
|
println("\nSYN-USDC details:")
|
|
println(" Min order size: ${market.minOrderSize}")
|
|
println(" Tick size: ${market.tickSize}")
|
|
println(" Maker fee: ${market.makerFee}%")
|
|
println(" Taker fee: ${market.takerFee}%")
|
|
|
|
// Get market statistics
|
|
val stats = dex.markets.getStats("SYN-USDC")
|
|
println("\nMarket statistics:")
|
|
println(" High 24h: ${stats.high24h}")
|
|
println(" Low 24h: ${stats.low24h}")
|
|
println(" Open interest: ${stats.openInterest}")
|
|
println(" Funding rate: ${stats.fundingRate}%")
|
|
|
|
println()
|
|
}
|
|
|
|
suspend fun spotTradingExample(dex: SynorDex) {
|
|
println("=== Spot Trading ===")
|
|
|
|
// Place a limit order
|
|
println("Placing limit buy order...")
|
|
val limitOrder = dex.spot.placeOrder(
|
|
OrderRequest(
|
|
market = "SYN-USDC",
|
|
side = OrderSide.BUY,
|
|
orderType = OrderType.LIMIT,
|
|
price = "1.50",
|
|
quantity = "100",
|
|
timeInForce = TimeInForce.GTC
|
|
)
|
|
)
|
|
|
|
println("Limit order placed:")
|
|
println(" Order ID: ${limitOrder.orderId}")
|
|
println(" Status: ${limitOrder.status}")
|
|
println(" Price: ${limitOrder.price}")
|
|
println(" Quantity: ${limitOrder.quantity}")
|
|
|
|
// Place a market order
|
|
println("\nPlacing market sell order...")
|
|
val marketOrder = dex.spot.placeOrder(
|
|
OrderRequest(
|
|
market = "SYN-USDC",
|
|
side = OrderSide.SELL,
|
|
orderType = OrderType.MARKET,
|
|
quantity = "50"
|
|
)
|
|
)
|
|
|
|
println("Market order executed:")
|
|
println(" Order ID: ${marketOrder.orderId}")
|
|
println(" Status: ${marketOrder.status}")
|
|
println(" Filled: ${marketOrder.filledQuantity}")
|
|
println(" Avg price: ${marketOrder.averagePrice}")
|
|
|
|
// Get order status
|
|
val status = dex.spot.getOrder(limitOrder.orderId)
|
|
println("\nOrder status:")
|
|
println(" Status: ${status.status}")
|
|
println(" Filled: ${status.filledQuantity} / ${status.quantity}")
|
|
println(" Remaining: ${status.remainingQuantity}")
|
|
|
|
// Cancel order
|
|
println("\nCancelling order...")
|
|
dex.spot.cancelOrder(limitOrder.orderId)
|
|
println("Order cancelled successfully")
|
|
|
|
// Get open orders
|
|
val openOrders = dex.spot.getOpenOrders("SYN-USDC")
|
|
println("\nOpen orders: ${openOrders.size}")
|
|
|
|
// Get trade history
|
|
val trades = dex.spot.getTradeHistory("SYN-USDC", limit = 10)
|
|
println("\nRecent trades: ${trades.size}")
|
|
trades.take(3).forEach { trade ->
|
|
println(" ${trade.side} ${trade.quantity} @ ${trade.price} (${trade.timestamp})")
|
|
}
|
|
|
|
println()
|
|
}
|
|
|
|
suspend fun perpsTradingExample(dex: SynorDex) {
|
|
println("=== Perpetual Futures Trading ===")
|
|
|
|
// Get available perps markets
|
|
val perpsMarkets = dex.perps.listMarkets()
|
|
println("Available perps markets: ${perpsMarkets.size}")
|
|
|
|
perpsMarkets.take(3).forEach { market ->
|
|
println(" ${market.symbol}: ${market.markPrice} (funding: ${market.fundingRate}%)")
|
|
}
|
|
|
|
// Open a long position
|
|
println("\nOpening long position...")
|
|
val position = dex.perps.openPosition(
|
|
PerpsOrderRequest(
|
|
market = "SYN-USDC-PERP",
|
|
side = OrderSide.BUY,
|
|
orderType = OrderType.LIMIT,
|
|
price = "1.50",
|
|
size = "1000",
|
|
leverage = 10,
|
|
reduceOnly = false
|
|
)
|
|
)
|
|
|
|
println("Position opened:")
|
|
println(" Position ID: ${position.positionId}")
|
|
println(" Size: ${position.size}")
|
|
println(" Entry price: ${position.entryPrice}")
|
|
println(" Leverage: ${position.leverage}x")
|
|
println(" Liquidation price: ${position.liquidationPrice}")
|
|
|
|
// Get position details
|
|
val details = dex.perps.getPosition(position.positionId)
|
|
println("\nPosition details:")
|
|
println(" Unrealized PnL: ${details.unrealizedPnL}")
|
|
println(" Margin: ${details.margin}")
|
|
println(" Margin ratio: ${details.marginRatio}%")
|
|
|
|
// Set stop loss and take profit
|
|
println("\nSetting stop loss and take profit...")
|
|
dex.perps.setStopLoss(position.positionId, "1.40")
|
|
println("Stop loss set at 1.40")
|
|
|
|
dex.perps.setTakeProfit(position.positionId, "1.80")
|
|
println("Take profit set at 1.80")
|
|
|
|
// Close position
|
|
println("\nClosing position...")
|
|
val closeResult = dex.perps.closePosition(position.positionId)
|
|
println("Position closed:")
|
|
println(" Realized PnL: ${closeResult.realizedPnL}")
|
|
println(" Close price: ${closeResult.closePrice}")
|
|
|
|
// Get all positions
|
|
val positions = dex.perps.getPositions()
|
|
println("\nOpen positions: ${positions.size}")
|
|
|
|
// Get funding history
|
|
val funding = dex.perps.getFundingHistory("SYN-USDC-PERP", limit = 10)
|
|
println("Funding payments: ${funding.size}")
|
|
|
|
println()
|
|
}
|
|
|
|
suspend fun liquidityExample(dex: SynorDex) {
|
|
println("=== Liquidity Provision ===")
|
|
|
|
// Get available pools
|
|
val pools = dex.liquidity.listPools()
|
|
println("Available pools: ${pools.size}")
|
|
|
|
pools.take(3).forEach { pool ->
|
|
println("\n ${pool.name}:")
|
|
println(" TVL: \$${pool.tvl}")
|
|
println(" APR: ${pool.apr}%")
|
|
println(" Volume 24h: \$${pool.volume24h}")
|
|
println(" Fee tier: ${pool.feeTier}%")
|
|
}
|
|
|
|
// Get pool details
|
|
val pool = dex.liquidity.getPool("SYN-USDC")
|
|
println("\nSYN-USDC pool details:")
|
|
println(" Token0: ${pool.token0.symbol} (${pool.token0Reserve})")
|
|
println(" Token1: ${pool.token1.symbol} (${pool.token1Reserve})")
|
|
println(" Price: ${pool.price}")
|
|
println(" Total LP tokens: ${pool.totalLPTokens}")
|
|
|
|
// Add liquidity
|
|
println("\nAdding liquidity...")
|
|
val addResult = dex.liquidity.addLiquidity(
|
|
AddLiquidityRequest(
|
|
pool = "SYN-USDC",
|
|
amount0 = "100",
|
|
amount1 = "150",
|
|
slippageBps = 50 // 0.5%
|
|
)
|
|
)
|
|
|
|
println("Liquidity added:")
|
|
println(" LP tokens received: ${addResult.lpTokens}")
|
|
println(" Position ID: ${addResult.positionId}")
|
|
println(" Share of pool: ${addResult.shareOfPool}%")
|
|
|
|
// Get LP positions
|
|
val lpPositions = dex.liquidity.getPositions()
|
|
println("\nLP positions: ${lpPositions.size}")
|
|
lpPositions.forEach { pos ->
|
|
println(" ${pos.pool}: ${pos.lpTokens} LP tokens (value: \$${pos.value})")
|
|
}
|
|
|
|
// Claim fees
|
|
println("\nClaiming fees...")
|
|
val fees = dex.liquidity.claimFees(addResult.positionId)
|
|
println("Fees claimed:")
|
|
println(" Token0: ${fees.amount0}")
|
|
println(" Token1: ${fees.amount1}")
|
|
|
|
// Remove liquidity
|
|
println("\nRemoving liquidity...")
|
|
val removeResult = dex.liquidity.removeLiquidity(
|
|
RemoveLiquidityRequest(
|
|
positionId = addResult.positionId,
|
|
lpTokens = addResult.lpTokens,
|
|
slippageBps = 50
|
|
)
|
|
)
|
|
|
|
println("Liquidity removed:")
|
|
println(" Token0 received: ${removeResult.amount0}")
|
|
println(" Token1 received: ${removeResult.amount1}")
|
|
|
|
println()
|
|
}
|
|
|
|
suspend fun orderbookExample(dex: SynorDex) {
|
|
println("=== Order Book ===")
|
|
|
|
// Get order book snapshot
|
|
val orderbook = dex.orderbook.getSnapshot("SYN-USDC", depth = 10)
|
|
|
|
println("Order book for SYN-USDC:")
|
|
println("\nAsks (sells):")
|
|
orderbook.asks.take(5).forEach { ask ->
|
|
println(" ${ask.quantity} @ ${ask.price}")
|
|
}
|
|
|
|
println("\nBids (buys):")
|
|
orderbook.bids.take(5).forEach { bid ->
|
|
println(" ${bid.quantity} @ ${bid.price}")
|
|
}
|
|
|
|
println("\nSpread: ${orderbook.spread} (${orderbook.spreadPercent}%)")
|
|
println("Mid price: ${orderbook.midPrice}")
|
|
|
|
// Get recent trades
|
|
val recentTrades = dex.orderbook.getRecentTrades("SYN-USDC", limit = 10)
|
|
println("\nRecent trades:")
|
|
recentTrades.take(5).forEach { trade ->
|
|
println(" ${trade.side} ${trade.quantity} @ ${trade.price}")
|
|
}
|
|
|
|
println()
|
|
}
|
|
|
|
suspend fun portfolioExample(dex: SynorDex) {
|
|
println("=== Portfolio ===")
|
|
|
|
// Get portfolio overview
|
|
val portfolio = dex.portfolio.getOverview()
|
|
|
|
println("Portfolio overview:")
|
|
println(" Total value: \$${portfolio.totalValue}")
|
|
println(" Available balance: \$${portfolio.availableBalance}")
|
|
println(" In orders: \$${portfolio.inOrders}")
|
|
println(" In positions: \$${portfolio.inPositions}")
|
|
println(" Unrealized PnL: \$${portfolio.unrealizedPnL}")
|
|
|
|
// Get balances
|
|
val balances = dex.portfolio.getBalances()
|
|
println("\nBalances:")
|
|
balances.forEach { balance ->
|
|
println(" ${balance.asset}: ${balance.total} (available: ${balance.available}, in orders: ${balance.inOrders})")
|
|
}
|
|
|
|
// Get PnL history
|
|
val pnlHistory = dex.portfolio.getPnLHistory(days = 30) // Last 30 days
|
|
println("\nPnL history (last ${pnlHistory.size} days):")
|
|
if (pnlHistory.isNotEmpty()) {
|
|
println(" Total PnL: \$${pnlHistory.last().cumulativePnL}")
|
|
}
|
|
|
|
// Get trade statistics
|
|
val stats = dex.portfolio.getStats()
|
|
println("\nTrade statistics:")
|
|
println(" Total trades: ${stats.totalTrades}")
|
|
println(" Win rate: ${stats.winRate}%")
|
|
println(" Avg profit: \$${stats.avgProfit}")
|
|
println(" Avg loss: \$${stats.avgLoss}")
|
|
println(" Best trade: \$${stats.bestTrade}")
|
|
println(" Worst trade: \$${stats.worstTrade}")
|
|
|
|
println()
|
|
}
|