Integrations

Bridges, wallet providers, & DeFi protocols.

Overview

Torque integrates with multiple protocols & services to provide comprehensive DeFi functionality:

Same-chain trading

Trade routing & aggregation across DEXs

Cross-chain bridge

Bridge aggregation for transfers across chains

Lending & borrowing

Supply assets to earn yield or borrow against collateral

Wallet Providers

20+ wallet integrations via RainbowKit

Cross-chain bridge

Torque aggregates bridges & selects the best route for each cross-chain transfer based on speed, cost, & security.

View transfer 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

Additional bridges: Celer, Multichain, Synapse, Wormhole, LayerZero, & more.

Bridge Selection

Torque automatically selects the best bridge based on speed, cost, security, liquidity, & token support.

lifi-config.ts

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 two connection paths: Continue with Email (Torque smart wallet) & Connect External Wallet (RainbowKit EOA). One active wallet at a time (Torque Wallet or external EOA).

View Wallet & Chains →

EOA vs Smart Wallet

Feature	External (EOA)	Torque (Smart)
Connect	RainbowKit	Email OTP → smart account
Borrow	Not supported	Supported
Trade / Lend	You pay gas	Gasless where implemented
Gas	User pays	Torque sponsorship

Browser Extension Wallets (EOA)

✓MetaMask

✓Rainbow Wallet

✓Trust Wallet

✓Phantom

✓Rabby

✓Taho

✓Brave Wallet

✓Core Wallet

✓TokenPocket

✓imToken

✓1inch Wallet

✓OKX Wallet

✓Uniswap Wallet

Smart Wallets

Torque Wallet (Continue with Email)

Email OTP → smart account. Gasless via Torque's sponsorship policy.

Safe Wallet (Gnosis Safe)

Multi-sig support, enterprise security, transaction policies

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

wallet-connection.tsx

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>
  )
}

Same-chain trading

Torque aggregates liquidity from multiple DEXs to find the best prices for same-chain trades.

View trade 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

Trade API

trade-routes.ts

// Get trade routes
const route = await getTradeRoute({
  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 executeTrade({
  route,
  walletClient
})

Lending & borrowing

Torque lets users supply assets to earn yield or borrow against collateral across supported markets.

View lend documentation →

Supported Markets

Ethereum Mainnet
Base
Arbitrum
Polygon
Optimism

Supported Assets

USDC, USDT, DAI (Stablecoins)
ETH, WETH (Native tokens)
WBTC (Bitcoin)
& more...

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

staking.ts

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

Bronze0% cashback

Silver25% cashback

Gold50% cashback

Platinum75% cashback

Diamond95% cashback

Fee Distributor API

fee-distributor.ts

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.pendingCashback

Additional Protocols

Lending Protocols

Torque supports multiple lending markets:

Primary lending markets
Morpho: Capital-efficient lending
Compound V3: Lending markets
Silo: Isolated lending pools
Spark: Aave fork

Examples

Complete Bridge Transfer

bridge-transfer.ts

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 flow

trade-flow.ts

// 1. Get trade route
const route = await getTradeRoute({
  fromAddress: address,
  chainId: 1,
  tokenIn: [usdcAddress],
  tokenOut: [wethAddress],
  amountIn: [parseUnits('1000', 6).toString()],
  slippage: 50,
  routingStrategy: 'delegate'
})

// 2. Check approval
const approval = await getTradeApproval({
  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 executeTrade({
  route: route.bestRoute,
  walletClient
})

Integration Best Practices

Bridge Selection

Let Torque 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

Was this helpful?

← API Reference Trade →