Integrations
Integrations
Complete documentation for Torque's integrations including bridges, wallet providers, & DeFi protocols.
Overview
Torque integrates with multiple protocols & services to provide comprehensive DeFi functionality:
Enso Finance
Same-chain trade routing & aggregation
LI.FI
Cross-chain bridge aggregation
Aave V3
Lending & borrowing
Wallet Providers
20+ wallet integrations via RainbowKit
Bridge Integration (LI.FI)
LI.FI provides bridge aggregation, automatically selecting the best bridge for each cross-chain transfer based on speed, cost, & security.
View LI.FI documentation →Stargate
Type: Liquidity Network Bridge
Features:
- Fast transfers
- Low fees
- Native asset support
- Unified liquidity pools
Best For: USDC, USDT transfers, fast transfers, high liquidity routes
Hop Protocol
Type: Optimistic Bridge
Features:
- Fast transfers
- Low fees
- Multiple token support
- Optimistic rollup technology
Best For: ETH transfers, fast withdrawals, Layer 2 transfers
Across
Type: Capital Efficient Bridge
Features:
- Capital efficiency
- Fast transfers
- Low fees
- Single transaction
Best For: Large transfers, cost-sensitive transfers, Ethereum ↔ Layer 2
Socket
Type: Multi-Bridge Aggregator
Features:
- Multi-bridge routing
- Optimal path finding
- Gas optimization
- Multiple token support
Best For: Complex routes, multi-hop transfers, optimal routing
Additional Bridges
LI.FI also supports: Celer, Multichain, Synapse, Wormhole, LayerZero, & more...
Bridge Selection
LI.FI automatically selects the best bridge based on speed, cost, security, liquidity, & token support.
import { createConfig, EVM } from '@lifi/sdk'
const config = createConfig({
integrator: 'Torque',
apiKey: process.env.NEXT_PUBLIC_LIFI_API_KEY,
providers: [
EVM({
getWalletClient: async () => {
// Get wallet client from Wagmi
},
switchChain: async (chainId) => {
// Switch chain in wallet
}
})
],
preloadChains: true
})Wallet Integration
Torque supports 20+ wallet providers through RainbowKit integration, providing users with a wide range of wallet options.
View Wallet & Chains →Browser Extension Wallets
Smart Wallets
Safe Wallet (Gnosis Safe)
Multi-sig support, enterprise security, transaction policies
Base Account
Account abstraction, gasless transactions, social recovery
Hardware Wallets
Ledger
Cold storage security, support for 1000+ tokens, multi-chain support
Protocol Wallets
WalletConnect
Connect any WalletConnect-compatible wallet, QR code scanning, mobile wallet support
Wallet Connection API
import { useAccount, useConnect, useDisconnect } from 'wagmi'
import { ConnectButton } from '@rainbow-me/rainbowkit'
function WalletConnection() {
const { address, isConnected } = useAccount()
const { connect, connectors } = useConnect()
const { disconnect } = useDisconnect()
return (
<div>
{isConnected ? (
<div>
<p>Connected: {address}</p>
<button onClick={() => disconnect()}>Disconnect</button>
</div>
) : (
<ConnectButton />
)}
</div>
)
}Enso Finance Integration
Enso Finance provides same-chain trade routing, aggregating liquidity from multiple DEXs to find the best prices.
View Enso documentation →Supported DEXs
Uniswap V2/V3, Curve, Balancer, 1inch, 0x, KyberSwap, & more...
Features
- Multi-DEX Routing: Finds best route across multiple DEXs
- Price Optimization: Best execution price
- MEV Protection: Protection against front-running
- Gas Optimization: Optimized transaction paths
Enso API
// Get trade routes
const route = await fetchEnsoRoutes({
fromAddress: '0x...',
chainId: 1,
tokenIn: ['0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'], // USDC
tokenOut: ['0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'], // WETH
amountIn: ['1000000000'], // 1000 USDC (6 decimals)
slippage: 50, // 0.5% in basis points
routingStrategy: 'delegate'
})
// Execute route
const txHash = await executeEnsoRoute({
route,
walletClient
})Aave V3 Integration
Aave V3 provides lending & borrowing functionality, allowing users to supply assets to earn yield or borrow against collateral.
View Aave documentation →Supported Markets
- Ethereum Mainnet
- Base
- Arbitrum
- Polygon
- Optimism
Supported Assets
- USDC, USDT, DAI (Stablecoins)
- ETH, WETH (Native tokens)
- WBTC (Bitcoin)
- & more...
Aave Features
- Lending: Supply assets to earn yield
- Borrowing: Borrow against collateral
- Health Factor: Monitor liquidation risk
- Interest Rates: Variable rates based on utilization
Staking Integration
Torque provides native staking functionality for TORQ tokens, allowing users to stake TORQ to earn stTORQ (staked TORQ).
Supported Chains
- Ethereum Mainnet
- Base
- Arbitrum
Staking API
import {
getTorqBalance,
getStTorqBalance,
stakeTorq,
unstakeStTorq,
convertToStTorq,
convertToTorq
} from '@/lib/staking-client'
// Get balances
const torqBalance = await getTorqBalance(address, chainId)
const stBalance = await getStTorqBalance(address, chainId)
// Stake TORQ
await approveTorq(amount, chainId)
const txHash = await stakeTorq(amount, chainId)
// Unstake stTORQ
const txHash = await unstakeStTorq(amount, chainId)
// Convert amounts
const stAmount = await convertToStTorq(torqAmount, chainId)
const torqAmount = await convertToTorq(stAmount, chainId)Fee Distributor Integration
The Fee Distributor contract enables tier-based fee cashback distribution. Users receive ETH cashback based on their tier when fees are collected.
Tier System
Fee Distributor API
import FeeDistributorABI from '@/lib/contracts/abis/FeeDistributor.json'
// Claim cashback
await writeContract({
address: FEE_DISTRIBUTOR_ADDRESS,
abi: FeeDistributorABI,
functionName: 'distributePendingCashback',
args: [address]
})
// Get pending cashback
const cashback = await query(api.fee_analytics.getUserFeeCashback, {
walletAddress: address
})
const pendingCashback = cashback.pendingCashbackAdditional Protocols
Lending Protocols
Torque supports multiple lending protocols through Enso integration:
- Aave V3: Primary lending protocol
- Morpho: Capital-efficient lending
- Compound V3: Lending markets
- Silo: Isolated lending pools
- Spark: Aave fork
Examples
Complete Bridge Transfer
import { getRoutes, executeRoute } from '@lifi/sdk'
// 1. Get bridge route
const routes = await getRoutes({
fromChainId: 1, // Ethereum
toChainId: 8453, // Base
fromTokenAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
toTokenAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913', // USDC on Base
fromAmount: '1000000000', // 1000 USDC
fromAddress: address,
options: {
slippage: 0.005,
order: 'CHEAPEST'
}
})
// 2. Select best route
const bestRoute = routes.routes[0]
// 3. Execute bridge
const result = await executeRoute({
route: bestRoute,
signer: walletClient,
updateRouteHook: (updatedRoute) => {
console.log('Route updated:', updatedRoute)
}
})Complete Trade with Enso
// 1. Get trade route
const route = await fetchEnsoRoutes({
fromAddress: address,
chainId: 1,
tokenIn: [usdcAddress],
tokenOut: [wethAddress],
amountIn: [parseUnits('1000', 6).toString()],
slippage: 50,
routingStrategy: 'delegate'
})
// 2. Check approval
const approval = await fetchEnsoApproval({
fromAddress: address,
tokenAddress: usdcAddress,
chainId: 1,
amount: parseUnits('1000', 6).toString()
})
// 3. Approve if needed
if (approval.approvalNeeded) {
await sendTransaction(approval.approvalData)
}
// 4. Execute trade
const txHash = await executeEnsoRoute({
route: route.bestRoute,
walletClient
})Integration Best Practices
Bridge Selection
- Let LI.FI choose: Don't manually select bridges
- Check routes: Verify route before executing
- Monitor status: Track bridge transaction status
- Handle errors: Implement error handling for failed bridges
Wallet Integration
- Support multiple wallets: Don't limit to one wallet
- Handle disconnections: Gracefully handle wallet disconnects
- Network switching: Support network switching
- Error handling: Handle wallet errors gracefully
Protocol Integration
- Rate limiting: Respect API rate limits
- Error handling: Implement comprehensive error handling
- Retry logic: Implement retry for failed requests
- Caching: Cache protocol data when appropriate