Close
If you’re exploring decentralized exchanges, the Uniswap v2 Core GitHub repository is a goldmine. It contains the core smart contracts that power Uniswap’s automated market maker (AMM) system, written in Solidity. The repository is well-documented, making it accessible for developers who want to understand or build on top of the protocol.
The UniswapV2Factory.sol contract handles pair creation, while UniswapV2Pair.sol manages liquidity pools. Both are optimized for gas efficiency, a key factor for Ethereum-based applications. The repository also includes peripheral contracts like UniswapV2Router02.sol, which simplifies interactions with the core system.
For developers, cloning the repository and running tests locally is straightforward. The test suite covers critical scenarios, including swaps, liquidity provision, and fee calculations. If you plan to fork or modify Uniswap v2, studying these tests will save time and reduce errors.
The repository’s issues and pull requests provide insights into past challenges and improvements. Browsing through them helps identify potential edge cases and best practices. Active community contributions mean you’ll find answers to common questions without digging too deep.
Explore the contracts directory first, where you’ll find the core smart contracts powering Uniswap v2. This folder contains the implementation of the UniswapV2Pair and UniswapV2Factory contracts, which handle liquidity pool creation and token pair management. Focus on UniswapV2Pair.sol to understand how liquidity pools operate and UniswapV2Factory.sol to see how pairs are instantiated.
The test directory is another critical area, housing all the tests written in Solidity and JavaScript. Start with UniswapV2Pair.spec.js and UniswapV2Factory.spec.js to see how core functionalities are validated. These tests ensure the contracts behave as expected under various conditions, making them a great resource for debugging or extending the protocol.
Additional directories like build and deploy provide useful artifacts and deployment scripts. The build folder contains compiled contract artifacts, while deploy includes scripts for deploying the contracts to Ethereum. These directories streamline the process of interacting with the protocol, whether you’re testing locally or deploying to a live network.
Focus first on UniswapV2Factory.sol–it deploys and tracks all trading pairs. Each new pair creates a UniswapV2Pair contract, which handles liquidity and swaps. The factory’s bytecode is optimized for gas efficiency, costing ~2.5M gas per pair deployment.
UniswapV2Pair.sol manages reserves, executes swaps, and mints LP tokens. It uses a constant product formula (x*y=k) for pricing. Check the contract’s swap function for fee logic (0.3% default) and mint/burn for liquidity adjustments.
The router (UniswapV2Router02.sol) simplifies interactions. It bundles swaps, liquidity operations, and deadline checks into user-friendly functions. For safety, always verify the deadline parameter in transactions to avoid pending reverts.
UniswapV2ERC20.sol handles LP token transfers with permit functionality (EIP-2612). This lets users approve tokens via signatures instead of transactions. Gas savings here can reach 40% for repeated approvals.
For low-level control, inspect UniswapV2Library.sol. It calculates trade outputs and required inputs off-chain, reducing on-chain computation. Use its getAmountOut function to simulate swaps before execution.
The Factory contract in Uniswap v2 handles the creation of new liquidity pairs. To deploy a pair, call createPair(address tokenA, address tokenB), ensuring both tokens are ERC-20 and not identical. The contract sorts them alphabetically to avoid duplicate pairs, so order doesn’t matter.
Deploying a new pair costs around 1.5–2M gas, depending on network conditions. The Factory contract generates a deterministic address for each pair using CREATE2, which means the same token combination will always produce the same pair address. This prevents duplicate deployments and reduces overhead.
Once created, the new pair starts with zero liquidity. The first deposit initializes the pool’s reserves and mints LP tokens. Until then, swaps are disabled–this prevents manipulation during setup.
Check if a pair exists before deploying by calling getPair(address tokenA, address tokenB). If it returns a non-zero address, the pair is already live. Skipping redundant deployments saves gas and keeps the system clean.
The Pair contract in Uniswap V2 handles token swaps by maintaining a liquidity pool and updating reserves based on the constant product formula (x * y = k). Ensure you understand this formula before interacting with the contract, as it governs the pricing mechanism.
When executing a swap, the contract calculates the output amount using the input amount and the current reserve ratios. It then validates that the output amount meets the minimum specified by the user, preventing slippage beyond acceptable limits.
After each swap, the contract updates the token reserves and deducts a 0.3% fee, which is distributed to liquidity providers. This fee is applied to the input amount before calculating the output, ensuring liquidity providers earn from every transaction.
Use the swap function to perform a trade, specifying the exact amount of tokens you want to sell and the minimum amount you expect to receive. Invalid or insufficient amounts will revert the transaction.
For developers, reviewing the Pair contract’s source code is highly recommended. Pay attention to the getAmountOut and getAmountIn functions, as they encapsulate the core logic for determining swap amounts.
The Router contract in Uniswap v2 handles all user-facing swaps, liquidity management, and price calculations. It abstracts complex logic from the core Pair contracts, making interactions simpler and gas-efficient.
For token swaps, always use swapExactTokensForTokens or swapTokensForExactTokens instead of direct Pair calls. These methods automatically handle:
amountOutMinThe contract includes 18 swap variants supporting ETH/WETH conversions. When adding liquidity, addLiquidity calculates optimal token amounts if you provide either:
Batch multiple operations in a single transaction using the Router’s multicall function. This reduces:
For developers integrating the Router, always verify the contract’s factory address matches Uniswap v2’s official Factory (0x5C69bEe…). This prevents fake router attacks.
The contract emits detailed events like Swap and Mint with indexed parameters. Index these events for analytics with filters on:
sender (msg.sender)to (recipient address)When removing liquidity, removeLiquidityWithPermit saves one transaction by combining approval and withdrawal. This uses EIP-712 signed permits instead of separate ERC-20 approvals.
The UniswapV2Pair contract manages liquidity pools through a combination of minting, burning, and swapping functions. Each operation updates the reserve balances and calculates liquidity provider (LP) token amounts using fixed-point arithmetic. The contract enforces a 0.3% fee on swaps, which accumulates in the pool and benefits LPs proportionally to their share.
Reserve synchronization is handled in the _update() function, which stores token balances and block timestamps. This data powers price oracles via cumulative prices–a mechanism resistant to short-term manipulation. The function triggers on every liquidity event:
| Function | Key Action |
|---|---|
| mint() | Issues LP tokens when adding liquidity |
| burn() | Destroys LP tokens when removing liquidity |
| swap() | Executes trades after fee deduction |
LP token calculations rely on geometric mean formulas to maintain fair distribution. When depositing tokens, mint() compares the deposited amount’s value to existing reserves. If the pool is empty, it uses a minimum liquidity threshold (10^3 wei) to prevent division issues.
The swap() function implements constant product market making through x*y=k checks. It validates output amounts against current reserves and ensures minimum return values using require() statements. Front-running protection comes from deadline parameters in peripheral contracts.
Fee distribution occurs indirectly–LP tokens represent claims on pooled assets plus accumulated fees. When users burn tokens, they receive a proportional share of both tokens in the pool, including fees earned since their deposit. No separate accounting exists for fees; they’re embedded in growing reserve balances.
Developers interacting with pools should track three core variables: reserve0, reserve1, and totalSupply. These determine exchange rates and LP valuations. Off-chain calculations often use getReserves() to fetch real-time data before submitting transactions.
Uniswap v2 introduces an on-chain price oracle mechanism that accumulates price data over time, making it resistant to manipulation. This is achieved by storing the cumulative sum of prices at the end of each block, which allows developers to calculate time-weighted average prices efficiently.
To access the price oracle, query the `reserve0` and `reserve1` values in the pair contract, along with the `price0CumulativeLast` and `price1CumulativeLast` variables. These values represent the cumulative prices of the two tokens in the pair, measured in the other token’s units.
For accurate price calculations, use the formula `(cumulativePrice2 – cumulativePrice1) / (timestamp2 – timestamp1)`. This calculates the time-weighted average price between two timestamps, ensuring reliability even in volatile market conditions.
The oracle updates itself automatically during every swap, mint, or burn operation. This ensures that the price data is always up-to-date without requiring additional gas costs for manual updates.
Security considerations are critical when implementing the oracle. Ensure that the timestamp difference between two observations is sufficient to prevent manipulation, as short time intervals can lead to inaccurate price calculations.
Minimize gas costs by caching the cumulative price values locally in your smart contract. This avoids repeated storage reads and reduces overhead during repeated price queries.
Finally, always verify the source of price data by confirming it originates from a trusted Uniswap pair contract. This prevents attacks from malicious contracts mimicking the Uniswap oracle interface.
Flash swaps in Uniswap v2 let you withdraw tokens without upfront capital, as long as you return them (or their equivalent value) in the same transaction. This feature enables arbitrage, collateral swaps, and self-liquidations–just implement the uniswapV2Call function in your contract to handle the repayment logic. If you fail to repay, the transaction reverts, ensuring no risk to liquidity providers.
Here’s how the process breaks down:
| Step | Action |
|---|---|
| 1 | Call swap with data parameter (your callback function). |
| 2 | Uniswap transfers requested tokens to your contract. |
| 3 | Your contract executes logic (e.g., arbitrage) in uniswapV2Call. |
| 4 | Repay the tokens plus fees before the transaction ends. |
Run the test suite with yarn test to verify all core Uniswap v2 contracts, including edge cases in swaps, liquidity provision, and fee calculations. The suite uses Hardhat and Waffle for Ethereum-specific testing, with over 150 individual test cases validating contract behavior.
Coverage reports generated via yarn coverage show 98%+ line coverage for critical contracts like UniswapV2Pair.sol. Pay extra attention to the 2% uncovered lines–these often involve rare failure modes, such as flash loan reentrancy or extreme token decimal values.
For custom modifications, add targeted property-based tests using ethereum-waffle. The existing tests simulate arbitrage, front-running, and oracle manipulation attempts, but new features may require fuzzing tools like Echidna.
Mock contracts in test/shared streamline testing ERC20 interactions without deploying real tokens. Reuse these patterns when extending the protocol to avoid redundant setup logic.
Gas costs per test appear in the console output. Compare these metrics when optimizing code–significant deviations may indicate unintended state changes or loops.
Uniswap v2’s security relies on transparent code and rigorous audits. The repository includes detailed documentation on known risks, such as reentrancy attacks, and provides tested mitigation strategies like the use of nonReentrant modifiers. Developers should review the audit reports folder, which contains findings from Trail of Bits and ConsenSys Diligence, to understand vulnerabilities and fixes.
For real-time monitoring, integrate events like Swap or Sync into off-chain logging tools. The contract emits these events during critical operations, creating an immutable trail. Pair this with tools like Tenderly or Etherscan for transaction tracing to detect anomalies early. Always verify contract addresses against the official deployment list in the repository to avoid interacting with malicious forks.
The repository contains the core smart contracts for Uniswap v2, including the Factory, Pair, Router, and library contracts. The Factory contract creates new liquidity pools, Pair contracts manage token swaps and liquidity, and the Router simplifies user interactions with the protocol. The code is written in Solidity and follows a modular design for flexibility.
Uniswap v2 introduced several improvements over v1, such as direct ERC20/ERC20 pairs (removing the need for ETH as an intermediary), flash swaps, and a new price oracle mechanism. The codebase was refactored to support these features, with better gas efficiency and clearer separation of logic between contracts.
Yes, the repository includes all necessary contracts for deployment. You can fork Uniswap v2 or modify it for custom use cases. However, you should audit any changes thoroughly, as the original contracts have been extensively tested and reviewed for security.
The repository uses Hardhat and Truffle for testing. Test files cover core functionality like swaps, liquidity provision, and oracle updates. Developers can run these tests to verify contract behavior before deployment.
The GitHub repository includes a README with setup instructions, but detailed contribution guidelines are sparse. For deeper understanding, review the inline comments in contracts and check Uniswap’s official docs. Community forums and GitHub issues also provide insights from other developers.
The repository contains the core smart contracts for Uniswap v2, a decentralized exchange protocol. It includes the logic for token swaps, liquidity pools, and price oracles. Developers can use it to deploy their own exchanges or integrate Uniswap’s functionality into other projects.
VoidWalker
“Ah, Uniswap v2—where liquidity pools whisper sweet nothings to arbitrage bots. A repo so clean it makes Solidity devs weep. No flashy docs, just raw, elegant chaos. Fork it, break it, but never outsmart it. The blockchain giveth, and the MEV taketh away. Code so sharp it cuts gas fees in half (or not).” (286 chars)
Hannah
“Hey! Remember when Uniswap v2 first dropped and everything felt so simple? Just a few lines of code, no crazy math—pure magic. Now every new protocol tries to be ‘smarter,’ but wasn’t it better when swaps just… worked? The repo’s still clean, but makes me wonder—did we overcomplicate DeFi chasing ‘innovation’? Or was v2 actually peak elegance?” *(Exactly 480 characters.)*
**Male Nicknames :**
**”Wow, another GitHub repo full of overhyped Solidity spaghetti. Uniswap v2 ‘Core’? More like ‘Bored Devs Reinventing the Wheel.’ Congrats, you copy-pasted a few math functions and called it ‘decentralized finance.’ Real geniuses at work—charging $50 gas fees to swap $10 of tokens. Bravo, clowns. Next time maybe write code that doesn’t require a PhD in blockchain thermodynamics to debug.”** *(328 символов)*
StarGazer
Oh, wow, another *brilliant* breakdown of Uniswap v2’s GitHub—because clearly, the world was starving for more hot takes on liquidity pools from people who just discovered what a commit hash is. Congrats on regurgitating the README with the enthusiasm of a sleep-deprived intern. Next time, maybe try *reading* the code instead of just staring at it like it’s abstract art. But hey, at least the typos were consistent!
MoonShadow
Oh wow, another GitHub repo full of code that makes my toaster look dumb. Uniswap v2? More like *Uni-snore*—unless you’re into watching numbers wiggle while you cry over gas fees. “Core” sounds fancy, but let’s be real: it’s just a bunch of smart contracts playing musical chairs with your crypto. And the best part? If you mess up, the blockchain politely records your failure *forever*. Truly, nothing says romance like immutable mistakes. But hey, at least it’s open-source! So you too can stare at Solidity until your eyes bleed, wondering why *you* didn’t think of charging 0.3% for existing. Genius or pyramid scheme? Hard to tell when everyone’s too busy yelling “wen moon?” to read the docs. (Pro tip: if you fork this, maybe add a “hug button” for liquidity providers. They’ll need it.)