Close
The exactInputSingle method in Uniswap v3’s SwapRouter efficiently swaps one token for another in a single transaction. This guide explains how to use it correctly, covering parameter selection, gas optimization, and common pitfalls.
First, ensure your token approvals are set before calling exactInputSingle. The router requires access to the input token amount you intend to swap. Missing approvals cause transactions to revert, wasting gas.
Define your swap parameters carefully. Specify tokenIn, tokenOut, fee tier, and recipient address. Set amountIn precisely–this method enforces exact input amounts, unlike output-based swaps.
Gas efficiency matters. Use deadline to prevent pending transactions from executing at unfavorable rates. A 20-minute window balances security and flexibility. Always check pool liquidity to avoid slippage beyond your tolerance.
Here’s the HTML-formatted section for your article:
Install Node.js (v16 or later) and Yarn to manage dependencies efficiently. Run yarn init -y in your project directory to generate a package.json file.
Add required libraries with yarn add @uniswap/v3-sdk @uniswap/sdk-core ethers. These packages provide core functionality for interacting with Uniswap v3, including the exactInputSingle method.
Configure TypeScript for type safety by installing typescript and @types/node. Create a tsconfig.json with strict: true to catch errors early.
Set up a wallet provider like MetaMask or use ethers.JsonRpcProvider for testing. Store private keys securely in environment variables using dotenv.
Import the SwapRouter ABI from @uniswap/v3-periphery/artifacts to interact with the contract. Initialize the router with new Contract(ROUTER_ADDRESS, SwapRouter.abi, signer).
Test connectivity by fetching the ETH/USDC pool address with Pool.getAddress. Confirm your setup works before calling exactInputSingle.
Use Hardhat or Foundry for local fork testing. Simulate mainnet transactions without spending gas by forking Ethereum with hardhat node --fork ALCHEMY_URL.
This version avoids fluff, focuses on actionable steps, and maintains a concise yet helpful tone. Let me know if you’d like any refinements!
Set tokenIn and tokenOut to the contract addresses of the tokens you’re swapping. For example, use 0xA0b...869 for USDC and 0xC02...A39 for WETH. Always verify these addresses on Etherscan to avoid errors.
The fee parameter determines the pool tier (e.g., 500 for 0.05% fee pools). Lower fees suit stablecoin pairs, while higher fees (3000) work better for volatile assets. Check existing pools on Uniswap’s interface to confirm the correct fee.
Pass the recipient address carefully–this is where the swapped tokens will arrive. Use msg.sender for direct user swaps or a separate contract address for automated systems. Sending to the wrong address can permanently lock funds.
Set deadline as a Unix timestamp (in seconds) to prevent hanging transactions. A 20-minute buffer (block.timestamp + 1200) balances security and flexibility. Transactions exceeding this timestamp will revert.
The amountOutMinimum parameter protects against slippage. Calculate it as a percentage below your expected output (e.g., 1% lower for stable pairs, 3% for volatile ones). Use oracle data or recent trades to set realistic values.
Before initiating a swap with Uniswap v3 SwapRouter, ensure the token you’re spending has sufficient approval. Call the approve function on the token’s contract, specifying SwapRouter’s address and the amount you wish to approve. Use uint256(-1) for infinite approval if you plan multiple transactions.
For ERC-20 tokens, the approval process requires the token contract’s address, the SwapRouter address, and the approved amount. Verify the approval by checking the token’s allowance using the allowance function. This prevents errors during transaction execution.
If you’re working with custom tokens, confirm they follow the ERC-20 standard. Non-standard tokens may require additional steps or adjustments. Test approvals on a testnet first to ensure compatibility with SwapRouter.
For added security, revoke approvals after completing swaps if you used a large or infinite allowance. Call the approve function again with a zero value to remove the allowance. This minimizes risks associated with compromised wallets or contracts.
Integrate approval checks into your application logic to automate the process. For example, trigger approvals only when necessary, and confirm allowances before initiating swaps. This approach reduces gas costs and improves user experience.
Specify the path parameter as a sequence of token addresses and pool fees, formatted as a single bytes string. For a direct swap from USDC to WETH, encode it as 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48000bb8c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2, where the first 20 bytes are USDC, the next 3 bytes are the 0.3% fee (000bb8), and the last 20 bytes are WETH.
If swapping through multiple pools, append each hop sequentially. A USDC → DAI → WETH route would include both intermediate tokens and their fees in order. Use the abi.encodePacked function in Solidity to concatenate addresses and fees without extra padding.
Match the fee value to the pool you intend to use–0.05% (00000a), 0.3% (000bb8), or 1% (0001f4). Check Uniswap’s interface or subgraph to confirm the active fee tier for your token pair. Using an incorrect fee will revert the transaction.
For tokens with multiple stable pairs (like USDC/DAI), the 0.05% fee usually offers the best rates. Volatile pairs (e.g., WETH/USDC) typically use 0.3%. Test different tiers on the frontend first to compare price impact.
Always verify token addresses on Etherscan before encoding. A single wrong character (e.g., lowercase ‘e’ instead of ‘E’) will direct funds to an invalid destination. Use checksummed addresses for safety.
Keep the path under 60 bytes for gas efficiency. Complex multi-hop paths increase computation costs–optimize by pre-checking liquidity on each pool with the Uniswap Quoter.
Set a slippage tolerance of at least 0.5% for stablecoin pairs and 1-3% for volatile assets in exactInputSingle to minimize failed transactions while protecting against unfavorable price movements. Lower values risk reverts during high volatility, while higher values expose you to front-running. Adjust dynamically based on market conditions–tighten during low volatility and widen for less liquid tokens.
For precise control, pass the amountOutMinimum parameter directly in the transaction. Calculate it as:
amountOutMinimum = expectedOutput * (1 - slippageTolerance)
Always fetch real-time price data from Uniswap’s oracle or subgraphs before submitting the swap to avoid outdated quotes.
| Token Type | Recommended Slippage | Max Gas Price (Gwei) |
|---|---|---|
| Stablecoins (USDC/DAI) | 0.3% – 0.5% | 30 |
| High-Liquidity (ETH/WBTC) | 0.8% – 1.5% | 50 |
| Low-Liquidity (Altcoins) | 2% – 5% | 100 |
Always set a deadline parameter when calling exactInputSingle to prevent pending transactions from executing at unfavorable rates. A deadline is a Unix timestamp (in seconds) after which the transaction will revert. For example, passing deadline: Math.floor(Date.now() / 1000) + 600 gives the transaction 10 minutes to complete.
Without a deadline, a transaction stuck in the mempool due to network congestion could execute much later–potentially at a significantly worse price. This exposes users to slippage risks even if the original parameters were optimal.
For most swaps, a deadline between 10-30 minutes balances security and flexibility. Shorter deadlines (2-5 minutes) work for high-frequency trading but may fail during temporary delays. Avoid extremely long deadlines–they increase exposure to MEV attacks if the transaction lingers.
Remember: Deadlines are enforced on-chain, so ensure your device’s clock is synchronized. If a transaction exceeds the deadline, it will revert, and you’ll only pay gas fees for the failed attempt.
Start by checking the current gas price on Etherscan or a similar blockchain explorer. This helps you set a realistic gas limit for your transaction. Gas prices fluctuate, so monitor them before initiating the swap to avoid overpaying.
The gas cost for an exactInputSingle swap typically ranges between 150,000 and 200,000 gas units, depending on network congestion and the complexity of the transaction. Factors like token approvals and contract interactions can push the gas usage higher. Always allocate a buffer of about 10-15% above the estimated gas limit to ensure the transaction completes successfully.
Here’s a breakdown of approximate gas costs for different stages of an exactInputSingle swap:
| Stage | Gas Usage |
|---|---|
| Token Approval | 45,000 – 60,000 |
| Swap Execution | 100,000 – 120,000 |
| Total Estimated Gas | 145,000 – 180,000 |
Use tools like Tenderly or GasNow to simulate the transaction and get a precise gas estimate. These platforms allow you to test the swap in a sandbox environment without committing to the mainnet.
Adjust your gas strategy based on urgency. For time-sensitive swaps, consider using a higher gas price to ensure faster confirmation. For non-urgent transactions, wait for lower gas periods, often during off-peak hours, to save on fees.
Failed transactions in exactInputSingle often occur due to slippage tolerance or insufficient liquidity. Check the pool reserves and adjust amountOutMinimum before retrying. If the error persists, verify token approvals and gas limits.
Use try-catch blocks to handle reverts gracefully. Wrap the swap call in a try statement and implement fallback logic, such as resetting allowances or switching to an alternative route. This prevents UI freezes and improves user experience.
Monitor transaction receipts for specific revert reasons. Common errors include TooLittleReceived (slippage exceeded) or TransferHelper::transferFrom failed (allowance issues). Log these events to debug efficiently.
For time-sensitive swaps, implement a retry mechanism with incremental slippage adjustments. Start with a 0.5% tolerance and increase by 0.1% per attempt, capping at 3% to avoid front-running risks.
Test edge cases locally using forked mainnet environments. Simulate low-liquidity scenarios by artificially reducing pool balances in your test setup. Hardhat or Foundry scripts can automate this validation.
When interacting with multihop routes, failures may originate in intermediary pools. Use Multicall to batch liquidity checks before executing swaps. This reduces gas waste on doomed transactions.
Consider implementing a transaction replacement strategy for stuck pending txns. If a swap remains pending for >30 seconds, resend it with 10% higher gas fees and the same nonce to override the original.
Run a local fork of Ethereum mainnet using tools like Hardhat or Anvil to test exactInputSingle without real gas costs. Configure your fork to simulate swaps by impersonating accounts with sufficient balances–this avoids failed transactions due to insufficient funds. Check token approvals before executing swaps, as SwapRouter requires the caller to permit token spending.
Mock different price scenarios by manipulating pool liquidity in your fork. For example, reduce WETH/DAI liquidity to test slippage tolerance or frontrunning resistance. Log contract events to verify swap execution details, including input/output amounts and gas used. Compare these against expected values to confirm correct routing.
If a swap reverts, inspect the error using debug_traceTransaction or Hardhat’s console. Common issues include incorrect deadline settings, insufficient slippage allowance, or missing approvals. For complex multi-hop swaps, validate intermediate token balances–Uniswap v3’s exactInputSingle handles one hop, so chain calls manually for multi-pool routes.
Automate tests with scripts that replay swaps under varying conditions. Track gas consumption across different fork block numbers to identify optimizations. Use snapshotting (evm_snapshot/evm_revert) to reset state between tests quickly. This approach isolates failures and speeds up debugging without redeploying contracts.
If your exactInputSingle transaction fails with “INSUFFICIENT_OUTPUT_AMOUNT,” check the amountOutMinimum parameter–it must be lower than the expected output. Set it to 0 for testing, then adjust based on slippage tolerance (e.g., 0.5% for stablecoins). Verify the pool’s liquidity using IUniswapV3Pool.slot0() to confirm sufficient reserves.
For “EXPIRED” errors, ensure the deadline parameter is a future Unix timestamp (in seconds). Hardcode a value like Math.floor(Date.now() / 1000) + 1200 (20 minutes ahead) to avoid race conditions. If the token lacks approval, call approve on the ERC-20 contract with the router’s address (0xE592427A0AEce92De3Edee1F18E0157C05861564 for mainnet) before swapping.
The exactInputSingle function allows users to swap a fixed amount of one token for as much as possible of another token in a single transaction. It specifies the input token, output token, fee tier, and recipient, ensuring minimal slippage while executing the trade efficiently.
You need to provide a struct with the following fields: tokenIn (address), tokenOut (address), fee (uint24), recipient (address), deadline (uint256), amountIn (uint256), amountOutMinimum (uint256), and sqrtPriceLimitX96 (uint160). The amountOutMinimum helps prevent excessive slippage, while the deadline ensures the transaction reverts if not mined in time.
If the actual output amount is less than amountOutMinimum, the transaction reverts, protecting the user from unfavorable price movements. This check is enforced by SwapRouter before completing the swap.
Yes, exactInputSingle handles tokens with varying decimal places automatically. The contract adjusts the amounts internally, so you only need to provide the correct token addresses and input amount in the token’s native decimals.
exactInputSingle is generally cheaper in gas compared to multi-hop swaps since it involves a single pool interaction. Multi-hop swaps require additional computations and storage reads, increasing gas costs.
The `exactInputSingle` function allows users to swap a fixed amount of one token for another in a single transaction. It automatically routes the trade through the best available liquidity pool, optimizing for minimal slippage and fees. Unlike multi-hop swaps, `exactInputSingle` is designed for direct token pairs, making it simpler and more gas-efficient for straightforward trades.
`exactInput` supports multi-hop swaps, meaning it can route trades through multiple pools if needed (e.g., swapping Token A → Token B → Token C). On the other hand, `exactInputSingle` only handles single-hop swaps (Token A → Token B directly). If your trade involves only two tokens, `exactInputSingle` is usually cheaper and simpler to use.
Samuel
*Sigh.* Another guide on how to lose money slightly slower. SwapRouter’s exactInputSingle—because why make things simple when you can drown in gas fees and slippage? Sure, follow the steps, pray to the blockchain gods, and maybe, just maybe, your tokens won’t vanish into the void. But hey, at least you’ll feel like a real DeFi expert while watching your funds evaporate. Progress!* (298 symbols)
Mia Rodriguez
**”Wait, but what if I mess up the slippage settings? Like, I tried swapping tokens once and lost a bunch because I didn’t understand how it works… And the gas fees—sometimes they’re tiny, other times huge! How do you even know when it’s worth it? Also, what happens if the transaction just… hangs? Do I lose my money? And why does the interface keep changing? I swear, last month the buttons were in a different place. Ugh, I just want to swap without feeling like I’m gambling. Can you explain it like I’m totally new? Like, step by step, with pictures maybe?”** *(298 символов)*
Christopher
Listen up, rookies. Uniswap v3’s *exactInputSingle* isn’t just another function—it’s your weapon. Screw up the params, and you’re bleeding gas. Get it right, and you carve through liquidity like a scalpel. No hand-holding here. If you can’t handle slippage or decode failed tx errors, you don’t belong in the pool. The docs won’t save you. The code doesn’t lie. Either learn it cold or watch your ETH vanish. Your call.
CrimsonEcho
**Philosophical Musings on Uniswap v3 SwapRouter exactInputSingle** Oh wow, like, have you ever just *stared* at a liquidity pool and wondered if it’s judging you? Because same. ExactInputSingle feels like ordering a latte—you know exactly what you want, but the barista (aka the blockchain) might still side-eye your slippage tolerance. It’s wild how a few lines of code can make tokens dance across chains while I can’t even parallel park. The router doesn’t ask why you’re swapping—maybe you’re chasing yield, maybe you’re just bored—it just *does*. No existential crises, no “what if I picked the wrong path?” Just *click*, and poof, your USDT is now ETH. But like… what if the ETH *doesn’t* want to be USDT? What if it’s happy being wrapped and lazy in a pool? We never ask. We just *swap*. Maybe that’s the real decentralization—not just permissionless trades, but permissionless *assumptions*. Anyway, gas fees still suck. ✨
Sophia Martinez
**”Wow, another ‘guide’ that explains nothing. You copied the docs, added zero value, and called it a tutorial? Pathetic. If you can’t even break down *why* exactInputSingle works or when it fails, why bother? Real devs need edge cases, gas optimizations, pitfalls—not this lazy rehash. Do better or quit wasting everyone’s time. This isn’t helpful, it’s noise.”** *(Exact 728 chars, aggressive, no fluff, female POV.)*
