యూనిస్వాప్-వి2 ఒప్పంద విశ్లేషణ

పరిచయం

Uniswap v2opens in a new tab ఏవైనా రెండు ERC-20 టోకెన్ల మధ్య మార్పిడి మార్కెట్ ను సృష్టించగలదు. ఈ వ్యాసంలో మేము ఈ ప్రోటోకాల్‌ను అమలు చేసే ఒప్పందాల కోసం సోర్స్ కోడ్‌ను పరిశీలిస్తాము మరియు అవి ఈ విధంగా ఎందుకు వ్రాయబడ్డాయో చూస్తాము.

యూనిస్వాప్ ఏమి చేస్తుంది?

సాధారణంగా, రెండు రకాల వినియోగదారులు ఉంటారు: ద్రవ్యత్వ ప్రదాతలు మరియు వ్యాపారులు.

ద్రవ్యత్వ ప్రదాతలు మార్పిడి చేయగల రెండు టోకెన్‌లతో పూల్‌ను అందిస్తారు (మేము వాటిని టోకెన్0 మరియు టోకెన్1 అని పిలుస్తాము). ప్రతిఫలంగా, వారు ద్రవ్యత్వ టోకెన్ అని పిలువబడే పూల్ యొక్క పాక్షిక యాజమాన్యాన్ని సూచించే మూడవ టోకెన్‌ను స్వీకరిస్తారు.

వ్యాపారులు ఒక రకమైన టోకెన్‌ను పూల్‌కు పంపి, ద్రవ్యత్వ ప్రదాతలచే అందించబడిన పూల్ నుండి మరొకటి (ఉదాహరణకు, టోకెన్0 ను పంపి, టోకెన్1 ను అందుకుంటారు) అందుకుంటారు. పూల్ కలిగి ఉన్న టోకెన్0ల మరియు టోకెన్1ల సాపేక్ష సంఖ్య ద్వారా మార్పిడి రేటు నిర్ణయించబడుతుంది. అదనంగా, ద్రవ్యత్వ పూల్ కోసం పూల్ ఒక చిన్న శాతాన్ని రివార్డ్‌గా తీసుకుంటుంది.

ద్రవ్యత్వ ప్రదాతలు తమ ఆస్తులను తిరిగి కోరుకున్నప్పుడు వారు పూల్ టోకెన్లను బర్న్ చేయవచ్చు మరియు వారి రివార్డ్ ల వాటాతో సహా వారి టోకెన్లను తిరిగి పొందవచ్చు.

పూర్తి వివరణ కోసం ఇక్కడ క్లిక్ చేయండిopens in a new tab.

v2 ఎందుకు? v3 ఎందుకు కాదు?

Uniswap v3opens in a new tab అనేది v2 కంటే చాలా క్లిష్టమైన అప్గ్రేడ్. మొదట v2 నేర్చుకుని తర్వాత v3 కి వెళ్లడం సులభం.

కోర్ ఒప్పందాలు vs పెరిఫెరీ ఒప్పందాలు

యూనిస్వాప్ v2 రెండు భాగాలుగా విభజించబడింది, ఒక కోర్ మరియు పెరిఫెరీ. ఈ విభజన ఆస్తులను కలిగి ఉన్న కోర్ ఒప్పందాలను, అందువల్ల సురక్షితంగా ఉండవలసి ఉంటుంది, సరళంగా మరియు ఆడిట్ చేయడానికి సులభంగా ఉండటానికి అనుమతిస్తుంది. వ్యాపారులకు అవసరమైన అన్ని అదనపు ఫంక్షనాలిటీని పెరిఫెరీ ఒప్పందాల ద్వారా అందించవచ్చు.

డేటా మరియు నియంత్రణ ప్రవాహాలు

మీరు యూనిస్వాప్ యొక్క మూడు ప్రధాన చర్యలను చేసినప్పుడు జరిగే డేటా మరియు నియంత్రణ ప్రవాహం ఇది:

1. విభిన్న టోకెన్ల మధ్య స్వాప్ చేయండి
2. మార్కెట్ కు ద్రవ్యత్వం జోడించి, జత మార్పిడి ERC-20 ద్రవ్యత్వ టోకెన్లతో రివార్డ్ పొందండి
3. ERC-20 ద్రవ్యత్వ టోకెన్లను బర్న్ చేసి, వ్యాపారులకు మార్పిడి చేయడానికి జత మార్పిడి అనుమతించే ERC-20 టోకెన్లను తిరిగి పొందండి

స్వాప్

ఇది వ్యాపారులు ఉపయోగించే అత్యంత సాధారణ ప్రవాహం:

కాలర్

1. స్వాప్ చేయవలసిన మొత్తంలో పెరిఫెరీ ఖాతాకు ఒక భత్యం అందించండి.
2. పెరిఫెరీ ఒప్పందం యొక్క అనేక స్వాప్ ఫంక్షన్లలో ఒకదానిని కాల్ చేయండి (ETH ప్రమేయం ఉందో లేదో, వ్యాపారి డిపాజిట్ చేయడానికి టోకెన్ల మొత్తాన్ని లేదా తిరిగి పొందడానికి టోకెన్ల మొత్తాన్ని పేర్కొంటాడో లేదో ఆధారపడి ఉంటుంది). ప్రతి స్వాప్ ఫంక్షన్ పాత్ను అంగీకరిస్తుంది, వెళ్లాల్సిన మార్పిడుల యొక్క శ్రేణి.

పెరిఫెరీ ఒప్పందంలో (UniswapV2Router02.sol)

3. మార్గం వెంట ప్రతి మార్పిడిలో వర్తకం చేయవలసిన మొత్తాలను గుర్తించండి.
4. మార్గంపై మళ్ళింపులు. మార్గం వెంట ప్రతి మార్పిడికి ఇది ఇన్‌పుట్ టోకెన్‌ను పంపుతుంది, ఆపై మార్పిడి యొక్క swap ఫంక్షన్‌ను పిలుస్తుంది. చాలా సందర్భాల్లో టోకెన్ల కోసం గమ్యస్థానం చిరునామా మార్గంలో తదుపరి జత మార్పిడి. తుది మార్పిడిలో అది వ్యాపారి అందించిన చిరునామా.

కోర్ ఒప్పందంలో (UniswapV2Pair.sol) {#in-the-core-contract-uniswapv2pairsol-2}5. కోర్ ఒప్పందం మోసం చేయబడలేదని మరియు స్వాప్ తర్వాత తగినంత ద్రవ్యతను కొనసాగించగలదని ధృవీకరించండి.

6. తెలిసిన నిల్వలకు అదనంగా మనకు ఎన్ని అదనపు టోకెన్లు ఉన్నాయో చూడండి. ఆ మొత్తం మార్పిడి కోసం మేము స్వీకరించిన ఇన్‌పుట్ టోకెన్ల సంఖ్య.
7. అవుట్పుట్ టోకెన్లను గమ్యస్థానానికి పంపండి.
8. నిల్వ మొత్తాలను అప్డేట్ చేయడానికి _update ని కాల్ చేయండి

పెరిఫెరీ ఒప్పందానికి తిరిగి (UniswapV2Router02.sol)

9. ఏవైనా అవసరమైన శుభ్రతను నిర్వహించండి (ఉదాహరణకు, వ్యాపారికి పంపడానికి ETH ను తిరిగి పొందడానికి WETH టోకెన్లను బర్న్ చేయండి)

ద్రవ్యతను జోడించండి

కాలర్

1. ద్రవ్యత్వ పూల్ కు జోడించవలసిన మొత్తాలలో పెరిఫెరీ ఖాతాకు ఒక భత్యం అందించండి.
2. పెరిఫెరీ ఒప్పందం యొక్క addLiquidity ఫంక్షన్లలో ఒకదానిని కాల్ చేయండి.

పెరిఫెరీ ఒప్పందంలో (UniswapV2Router02.sol)

3. అవసరమైతే కొత్త జత మార్పిడిని సృష్టించండి
4. ఒకవేళ ప్రస్తుతం ఒక జత మార్పిడి ఉంటే, జోడించడానికి టోకెన్ల మొత్తాన్ని లెక్కించండి. ఇది రెండు టోకెన్లకు ఒకేలాంటి విలువగా ఉండాలి, కాబట్టి కొత్త టోకెన్లకు మరియు ప్రస్తుతం ఉన్న టోకెన్లకు ఒకే నిష్పత్తి.
5. మొత్తాలు ఆమోదయోగ్యమైనవా అని తనిఖీ చేయండి (కాలర్లు ఒక కనీస మొత్తాన్ని పేర్కొనవచ్చు, దాని కంటే తక్కువ ద్రవ్యతను జోడించడానికి ఇష్టపడరు)
6. కోర్ ఒప్పందాన్ని కాల్ చేయండి.

కోర్ ఒప్పందంలో (UniswapV2Pair.sol)

7. ద్రవ్యత్వ టోకెన్లను మింట్ చేసి, వాటిని కాలర్ కు పంపండి
8. నిల్వ మొత్తాలను అప్డేట్ చేయడానికి _update ని కాల్ చేయండి

ద్రవ్యతను తొలగించండి

కాలర్

1. అండర్లయింగ్ టోకెన్ల మార్పిడి కోసం బర్న్ చేయవలసిన ద్రవ్యత్వ టోకెన్ల భత్యంతో పెరిఫెరీ ఖాతాను అందించండి.
2. పెరిఫెరీ ఒప్పందం యొక్క removeLiquidity ఫంక్షన్లలో ఒకదానిని కాల్ చేయండి.

పెరిఫెరీ ఒప్పందంలో (UniswapV2Router02.sol)

3. ద్రవ్యత్వ టోకెన్లను జత మార్పిడికి పంపండి

కోర్ ఒప్పందంలో (UniswapV2Pair.sol)

4. గమ్యస్థాన చిరునామాకు బర్న్ చేయబడిన టోకెన్ల నిష్పత్తిలో అండర్లయింగ్ టోకెన్లను పంపండి. ఉదాహరణకు, పూల్ లో 1000 ఎ టోకెన్లు, 500 బి టోకెన్లు మరియు 90 ద్రవ్యత్వ టోకెన్లు ఉంటే, మరియు మనం బర్న్ చేయడానికి 9 టోకెన్లను స్వీకరిస్తే, మనం ద్రవ్యత్వ టోకెన్లలో 10% బర్న్ చేస్తున్నాము, కాబట్టి మనం వినియోగదారునికి 100 ఎ టోకెన్లు మరియు 50 బి టోకెన్లు తిరిగి పంపుతాము.
5. ద్రవ్యత్వ టోకెన్లను బర్న్ చేయండి
6. నిల్వ మొత్తాలను అప్డేట్ చేయడానికి _update ని కాల్ చేయండి

కోర్ ఒప్పందాలు

ఇవి ద్రవ్యతను కలిగి ఉన్న సురక్షిత ఒప్పందాలు.

UniswapV2Pair.sol

ఈ ఒప్పందంopens in a new tab టోకెన్లను మార్పిడి చేసే అసలు పూల్ ను అమలు చేస్తుంది. ఇది కోర్ యూనిస్వాప్ ఫంక్షనాలిటీ.

1pragma solidity =0.5.16;
2
3import './interfaces/IUniswapV2Pair.sol';
4import './UniswapV2ERC20.sol';
5import './libraries/Math.sol';
6import './libraries/UQ112x112.sol';
7import './interfaces/IERC20.sol';
8import './interfaces/IUniswapV2Factory.sol';
9import './interfaces/IUniswapV2Callee.sol';
అన్నీ చూపించు
కాపీ

ఒప్పందం అమలు చేసే కారణంగా (IUniswapV2Pair మరియు UniswapV2ERC20) లేదా అవి అమలు చేసే ఒప్పందాలను పిలిచే కారణంగా, ఒప్పందానికి తెలిసి ఉండవలసిన అన్ని ఇంటర్ఫేస్లు ఇవి.

1contract UniswapV2Pair is IUniswapV2Pair, UniswapV2ERC20 {
కాపీ

ఈ ఒప్పందం UniswapV2ERC20 నుండి వారసత్వం పొందుతుంది, ఇది ద్రవ్యత్వ టోకెన్ల కోసం ERC-20 ఫంక్షన్లను అందిస్తుంది.

1    using SafeMath  for uint;
కాపీ

ఓవర్ఫ్లో మరియు అండర్ఫ్లోలను నివారించడానికి సేఫ్ మాథ్ లైబ్రరీopens in a new tab ఉపయోగించబడుతుంది. ఇది ముఖ్యం ఎందుకంటే లేకపోతే మనం -1 విలువ ఉండవలసిన పరిస్థితిలో ముగుస్తాము, కానీ బదులుగా 2^256-1 ఉంటుంది.

1    using UQ112x112 for uint224;
కాపీ

పూల్ ఒప్పందంలోని చాలా గణనలకు భిన్నాలు అవసరం. అయినప్పటికీ, భిన్నాలు EVM ద్వారా మద్దతు ఇవ్వబడవు. యూనిస్వాప్ కనుగొన్న పరిష్కారం 224 బిట్ విలువలను ఉపయోగించడం, పూర్ణాంక భాగం కోసం 112 బిట్స్ మరియు భిన్నం కోసం 112 బిట్స్. కాబట్టి 1.0 ను 2^112 గా, 1.5 ను 2^112 + 2^111 గా మొదలైనవిగా సూచిస్తారు.

ఈ లైబ్రరీ గురించి మరిన్ని వివరాలు పత్రంలో తరువాత అందుబాటులో ఉన్నాయి.

చరరాశులు

1    uint public constant MINIMUM_LIQUIDITY = 10**3;
కాపీ

సున్నాతో విభజన సందర్భాలను నివారించడానికి, ఎల్లప్పుడూ ఉండే కనీస సంఖ్యలో ద్రవ్యత్వ టోకెన్లు ఉన్నాయి (కానీ ఖాతా సున్నా యాజమాన్యంలో ఉంటాయి). ఆ సంఖ్య MINIMUM_LIQUIDITY, వెయ్యి.

1    bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
కాపీ

ఇది ERC-20 బదిలీ ఫంక్షన్ కోసం ABI సెలెక్టర్. ఇది రెండు టోకెన్ ఖాతాలలో ERC-20 టోకెన్లను బదిలీ చేయడానికి ఉపయోగించబడుతుంది.

1    address public factory;
కాపీ

ఈ పూల్ ను సృష్టించిన ఫ్యాక్టరీ ఒప్పందం ఇది. ప్రతి పూల్ రెండు ERC-20 టోకెన్ల మధ్య మార్పిడి, ఫ్యాక్టరీ ఈ పూల్స్ అన్నింటినీ కలిపే ఒక కేంద్ర బిందువు.

1    address public token0;
2    address public token1;
కాపీ

ఈ పూల్ ద్వారా మార్పిడి చేయగల రెండు రకాల ERC-20 టోకెన్ల కోసం ఒప్పందాల చిరునామాలు ఇవి.

1    uint112 private reserve0;           // ఒకే నిల్వ స్థానాన్ని ఉపయోగిస్తుంది, getReserves ద్వారా యాక్సెస్ చేయవచ్చు
2    uint112 private reserve1;           // ఒకే నిల్వ స్థానాన్ని ఉపయోగిస్తుంది, getReserves ద్వారా యాక్సెస్ చేయవచ్చు
కాపీ

ప్రతి టోకెన్ రకం కోసం పూల్ కలిగి ఉన్న నిల్వలు. మేము రెండూ ఒకే విలువను సూచిస్తాయని ఊహిస్తాము, కాబట్టి ప్రతి టోకెన్0 విలువ reserve1/reserve0 టోకెన్1 లు.

1    uint32  private blockTimestampLast; // ఒకే నిల్వ స్థానాన్ని ఉపయోగిస్తుంది, getReserves ద్వారా యాక్సెస్ చేయవచ్చు
కాపీ

ఒక మార్పిడి జరిగిన చివరి బ్లాక్ కోసం టైమ్స్టాంప్, కాలక్రమేణా మార్పిడి రేట్లను ట్రాక్ చేయడానికి ఉపయోగించబడుతుంది.

Ethereum ఒప్పందాల యొక్క అతిపెద్ద గ్యాస్ ఖర్చులలో ఒకటి నిల్వ, ఇది ఒప్పందం యొక్క ఒక కాల్ నుండి మరొక దానికి నిలుస్తుంది. ప్రతి నిల్వ కణం 256 బిట్స్ పొడవు ఉంటుంది. కాబట్టి మూడు వేరియబుల్స్, reserve0, reserve1, మరియు blockTimestampLast, ఒకే నిల్వ విలువ ఈ మూడింటిని చేర్చగల విధంగా కేటాయించబడ్డాయి (112+112+32=256).

1    uint public price0CumulativeLast;
2    uint public price1CumulativeLast;
కాపీ

ఈ వేరియబుల్స్ ప్రతి టోకెన్ కోసం సంచిత ఖర్చులను కలిగి ఉంటాయి (ప్రతి ఒక్కటి మరొకదాని పరంగా). కాలక్రమేణా సగటు మార్పిడి రేటును లెక్కించడానికి వాటిని ఉపయోగించవచ్చు.

1    uint public kLast; // reserve0 * reserve1, అత్యంత ఇటీవలి ద్రవ్యత్వ సంఘటన తర్వాత వెంటనే
కాపీ

టోకెన్0 మరియు టోకెన్1 మధ్య మార్పిడి రేటుపై జత మార్పిడి నిర్ణయించే విధానం ట్రేడ్ల సమయంలో రెండు నిల్వల యొక్క గుణకారాన్ని స్థిరంగా ఉంచడం. kLast ఈ విలువ. ఒక ద్రవ్యత్వ ప్రదాత టోకెన్లను డిపాజిట్ చేసినప్పుడు లేదా ఉపసంహరించుకున్నప్పుడు ఇది మారుతుంది, మరియు 0.3% మార్కెట్ రుసుము కారణంగా ఇది కొద్దిగా పెరుగుతుంది.

ఇక్కడ ఒక సాధారణ ఉదాహరణ. గమనించండి, సరళత కోసం పట్టికలో దశాంశ బిందువు తర్వాత మూడు అంకెలు మాత్రమే ఉన్నాయి, మరియు మేము 0.3% ట్రేడింగ్ రుసుమును విస్మరిస్తాము కాబట్టి సంఖ్యలు ఖచ్చితమైనవి కావు.

వ్యాపారులు టోకెన్0 ను ఎక్కువగా అందించే కొద్దీ, టోకెన్1 యొక్క సాపేక్ష విలువ పెరుగుతుంది మరియు సరఫరా మరియు డిమాండ్ ఆధారంగా దీనికి విరుద్ధంగా ఉంటుంది.

లాక్

1    uint private unlocked = 1;
కాపీ

పునఃప్రవేశ దుర్వినియోగంopens in a new tab ఆధారంగా ఉండే భద్రతా దుర్బలత్వాల యొక్క ఒక తరగతి ఉంది. యూనిస్వాప్ అనధికారిక ERC-20 టోకెన్లను బదిలీ చేయవలసి ఉంటుంది, అంటే వాటిని పిలిచే యూనిస్వాప్ మార్కెట్ ను దుర్వినియోగం చేయడానికి ప్రయత్నించే ERC-20 ఒప్పందాలను పిలవడం. ఒప్పందంలో భాగంగా unlocked వేరియబుల్ ను కలిగి ఉండటం ద్వారా, ఫంక్షన్లు నడుస్తున్నప్పుడు (ఒకే లావాదేవీలో) పిలవకుండా నిరోధించవచ్చు.

1    modifier lock() {
కాపీ

ఈ ఫంక్షన్ ఒక మాడిఫైయర్opens in a new tab, దాని ప్రవర్తనను మార్చడానికి ఒక సాధారణ ఫంక్షన్ చుట్టూ చుట్టుకునే ఫంక్షన్.

1        require(unlocked == 1, 'UniswapV2: LOCKED');
2        unlocked = 0;
కాపీ

unlocked ఒకటితో సమానంగా ఉంటే, దానిని సున్నాకు సెట్ చేయండి. ఇది ఇప్పటికే సున్నా అయితే కాల్ ను రద్దు చేయండి, దానిని విఫలం చేయండి.

1        _;
కాపీ

ఒక మాడిఫైయర్ లో _; అనేది అసలు ఫంక్షన్ కాల్ (అన్ని పారామీటర్లతో). ఇక్కడ ఫంక్షన్ కాల్ unlocked పిలిచినప్పుడు ఒకటిగా ఉంటేనే జరుగుతుందని అర్థం, మరియు అది నడుస్తున్నప్పుడు unlocked విలువ సున్నాగా ఉంటుంది.

1        unlocked = 1;
2    }
కాపీ

ప్రధాన ఫంక్షన్ తిరిగి వచ్చిన తర్వాత, లాక్ ను విడుదల చేయండి.

ఇతరములు ఫంక్షన్లు

1    function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
2        _reserve0 = reserve0;
3        _reserve1 = reserve1;
4        _blockTimestampLast = blockTimestampLast;
5    }
కాపీ

ఈ ఫంక్షన్ కాలర్లకు మార్పిడి యొక్క ప్రస్తుత స్థితిని అందిస్తుంది. Solidity ఫంక్షన్లు బహుళ విలువలను తిరిగి ఇవ్వగలవుopens in a new tab గమనించండి.

1    function _safeTransfer(address token, address to, uint value) private {
2        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
కాపీ

ఈ అంతర్గత ఫంక్షన్ మార్పిడి నుండి ERC20 టోకెన్ల మొత్తాన్ని మరొకరికి బదిలీ చేస్తుంది. SELECTOR మనం పిలుస్తున్న ఫంక్షన్ transfer(address,uint) అని పేర్కొంటుంది (పైన నిర్వచనం చూడండి).

టోకెన్ ఫంక్షన్ కోసం ఒక ఇంటర్ఫేస్ ను దిగుమతి చేసుకోవాల్సిన అవసరం లేకుండా, మేము ABI ఫంక్షన్లలోopens in a new tab ఒకదానిని ఉపయోగించి కాల్ ను "మాన్యువల్ గా" సృష్టిస్తాము.

1        require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');
2    }
కాపీ

ఒక ERC-20 బదిలీ కాల్ వైఫల్యాన్ని నివేదించగల రెండు మార్గాలు ఉన్నాయి:

1. తిరిగి వెళ్లండి. ఒక బాహ్య ఒప్పందానికి కాల్ తిరిగి వెళ్ళినట్లయితే, బూలియన్ రిటర్న్ విలువ false అవుతుంది
2. సాధారణంగా ముగించండి కానీ వైఫల్యాన్ని నివేదించండి. ఆ సందర్భంలో రిటర్న్ విలువ బఫర్ సున్నా కాని పొడవును కలిగి ఉంటుంది, మరియు బూలియన్ విలువగా డీకోడ్ చేసినప్పుడు అది false అవుతుంది

ఈ పరిస్థితులలో ఏది జరిగినా, తిరిగి వెళ్లండి.

సంఘటనలు

1    event Mint(address indexed sender, uint amount0, uint amount1);
2    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
కాపీ

ద్రవ్యత్వ ప్రదాత ద్రవ్యతను డిపాజిట్ చేసినప్పుడు (Mint) లేదా ఉపసంహరించుకున్నప్పుడు (Burn) ఈ రెండు సంఘటనలు విడుదల చేయబడతాయి. ఏ సందర్భంలోనైనా, డిపాజిట్ చేయబడిన లేదా ఉపసంహరించుకున్న టోకెన్0 మరియు టోకెన్1 మొత్తాలు సంఘటనలో భాగంగా ఉంటాయి, అలాగే మనల్ని పిలిచిన ఖాతా యొక్క గుర్తింపు (sender) కూడా ఉంటుంది. ఉపసంహరణ సందర్భంలో, సంఘటన టోకెన్లను స్వీకరించిన లక్ష్యాన్ని (to) కూడా కలిగి ఉంటుంది, ఇది పంపినవారికి సమానంగా ఉండకపోవచ్చు.

1    event Swap(
2        address indexed sender,
3        uint amount0In,
4        uint amount1In,
5        uint amount0Out,
6        uint amount1Out,
7        address indexed to
8    );
కాపీ

ఒక వ్యాపారి ఒక టోకెన్ ను మరొక దాని కోసం స్వాప్ చేసినప్పుడు ఈ సంఘటన విడుదల చేయబడుతుంది. మళ్ళీ, పంపినవారు మరియు గమ్యం ఒకేలా ఉండకపోవచ్చు. ప్రతి టోకెన్ మార్పిడికి పంపబడవచ్చు లేదా దాని నుండి స్వీకరించబడవచ్చు.

1    event Sync(uint112 reserve0, uint112 reserve1);
కాపీ

చివరగా, కారణంతో సంబంధం లేకుండా, తాజా నిల్వ సమాచారం (మరియు అందువల్ల మార్పిడి రేటు) అందించడానికి టోకెన్లు జోడించబడినప్పుడు లేదా ఉపసంహరించుకున్నప్పుడు ప్రతిసారీ Sync విడుదల చేయబడుతుంది.

సెటప్ ఫంక్షన్లు

కొత్త జత మార్పిడి ఏర్పాటు చేసినప్పుడు ఈ ఫంక్షన్లను ఒకసారి పిలవాలి.

1    constructor() public {
2        factory = msg.sender;
3    }
కాపీ

నిర్మాణకర్త జతను సృష్టించిన ఫ్యాక్టరీ యొక్క చిరునామాను మేము ట్రాక్ చేస్తామని నిర్ధారిస్తుంది. initialize మరియు ఫ్యాక్టరీ రుసుము (ఒకవేళ ఉంటే) కోసం ఈ సమాచారం అవసరం

1    // విస్తరణ సమయంలో ఫ్యాక్టరీ ద్వారా ఒకసారి పిలవబడుతుంది
2    function initialize(address _token0, address _token1) external {
3        require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // తగినంత తనిఖీ
4        token0 = _token0;
5        token1 = _token1;
6    }
కాపీ

ఈ ఫంక్షన్ ఫ్యాక్టరీకి (మరియు ఫ్యాక్టరీకి మాత్రమే) ఈ జత మార్పిడి చేసే రెండు ERC-20 టోకెన్లను పేర్కొనడానికి అనుమతిస్తుంది.

అంతర్గత నవీకరణ ఫంక్షన్లు

_update

1    // నిల్వలను నవీకరించండి మరియు, ప్రతి బ్లాక్ కు మొదటి కాల్ లో, ధర సంచితాలను
2    function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
కాపీ

టోకెన్లు డిపాజిట్ చేయబడినప్పుడు లేదా ఉపసంహరించుకున్నప్పుడు ప్రతిసారీ ఈ ఫంక్షన్ పిలవబడుతుంది.

1        require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
కాపీ

ఒకవేళ బ్యాలెన్స్0 లేదా బ్యాలెన్స్1 (uint256) uint112(-1) (=2^112-1) కంటే ఎక్కువగా ఉంటే (కాబట్టి అది ఓవర్ఫ్లో అవుతుంది & uint112 కు మార్చబడినప్పుడు తిరిగి 0 కు చుట్టబడుతుంది) ఓవర్ఫ్లోలను నివారించడానికి _అప్డేట్ కొనసాగించడాన్ని తిరస్కరించండి. 10^18 యూనిట్లుగా విభజించగల ఒక సాధారణ టోకెన్ తో, ప్రతి మార్పిడి ప్రతి టోకెన్లకు సుమారు 5.1*10^15 వరకు పరిమితం చేయబడిందని అర్థం. ఇప్పటివరకు అది సమస్య కాదు.

1        uint32 blockTimestamp = uint32(block.timestamp % 2**32);
2        uint32 timeElapsed = blockTimestamp - blockTimestampLast; // ఓవర్ఫ్లో కోరబడుతుంది
3        if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
కాపీ

గడచిన సమయం సున్నా కాకపోతే, ఈ బ్లాక్ లో మేము మొదటి మార్పిడి లావాదేవీ అని అర్థం. ఆ సందర్భంలో, మేము ధర సంచితాలను నవీకరించాలి.

1            // * ఎప్పుడూ ఓవర్ఫ్లో కాదు, మరియు + ఓవర్ఫ్లో కోరబడుతుంది
2            price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
3            price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
4        }
కాపీ

ప్రతి ధర సంచితం తాజా ధరతో (ఇతర టోకెన్ నిల్వ/ఈ టోకెన్ నిల్వ) సెకన్లలో గడచిన సమయంతో నవీకరించబడుతుంది. సగటు ధరను పొందడానికి, మీరు కాలంలో రెండు బిందువులలో సంచిత ధరను చదివి, వాటి మధ్య సమయ వ్యత్యాసంతో విభజిస్తారు. ఉదాహరణకు, ఈ సంఘటనల క్రమాన్ని ఊహించండి:

5,030 మరియు 5,150 టైమ్ స్టాంప్ ల మధ్య టోకెన్0 సగటు ధరను లెక్కించాలనుకుందాం. price0Cumulative విలువలో వ్యత్యాసం 143.702-29.07=114.632. ఇది రెండు నిమిషాల (120 సెకన్లు) సగటు. కాబట్టి సగటు ధర 114.632/120 = 0.955.

ఈ ధర గణన పాత నిల్వ పరిమాణాలను తెలుసుకోవాల్సిన కారణం.

1        reserve0 = uint112(balance0);
2        reserve1 = uint112(balance1);
3        blockTimestampLast = blockTimestamp;
4        emit Sync(reserve0, reserve1);
5    }
కాపీ

చివరగా, గ్లోబల్ వేరియబుల్స్ నవీకరించి Sync సంఘటనను విడుదల చేయండి.

_mintFee

1    // రుసుము ఆన్లో ఉంటే, sqrt(k) లోని పెరుగుదలలో 1/6 వ వంతుకు సమానమైన ద్రవ్యతను మింట్ చేయండి
2    function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
కాపీ

యూనిస్వాప్ 2.0లో వ్యాపారులు మార్కెట్ ను ఉపయోగించడానికి 0.30% రుసుము చెల్లిస్తారు. ఆ రుసుములో ఎక్కువ భాగం (ట్రేడ్ లో 0.25%) ఎల్లప్పుడూ ద్రవ్యత్వ ప్రదాతలకు వెళ్తుంది. మిగిలిన 0.05% ద్రవ్యత్వ ప్రదాతలకు లేదా ఫ్యాక్టరీ ద్వారా ప్రోటోకాల్ రుసుముగా పేర్కొన్న చిరునామాకు వెళ్ళవచ్చు, ఇది యూనిస్వాప్ కు వారి అభివృద్ధి ప్రయత్నానికి చెల్లిస్తుంది.

గణనలను (మరియు అందువల్ల గ్యాస్ ఖర్చులను) తగ్గించడానికి, ప్రతి లావాదేవీ వద్ద కాకుండా, పూల్ నుండి ద్రవ్యత జోడించబడినప్పుడు లేదా తీసివేయబడినప్పుడు మాత్రమే ఈ రుసుము లెక్కించబడుతుంది.

1        address feeTo = IUniswapV2Factory(factory).feeTo();
2        feeOn = feeTo != address(0);
కాపీ

ఫ్యాక్టరీ యొక్క రుసుము గమ్యాన్ని చదవండి. అది సున్నా అయితే ప్రోటోకాల్ రుసుము లేదు మరియు ఆ రుసుమును లెక్కించాల్సిన అవసరం లేదు.

1        uint _kLast = kLast; // గ్యాస్ పొదుపు
కాపీ

kLast స్థితి వేరియబుల్ నిల్వలో ఉంది, కాబట్టి ఒప్పందానికి విభిన్న కాల్ ల మధ్య దానికి ఒక విలువ ఉంటుంది. నిల్వకు ప్రాప్యత ఒప్పందానికి ఫంక్షన్ కాల్ ముగిసినప్పుడు విడుదల చేయబడే అస్థిర జ్ఞాపకశక్తికి ప్రాప్యత కంటే చాలా ఖరీదైనది, కాబట్టి మేము గ్యాస్ మీద ఆదా చేయడానికి ఒక అంతర్గత వేరియబుల్ ను ఉపయోగిస్తాము.

1        if (feeOn) {
2            if (_kLast != 0) {
కాపీ

ద్రవ్యత్వ ప్రదాతలు వారి ద్రవ్యత్వ టోకెన్ల ప్రశంసల ద్వారా తమ వాటాను పొందుతారు. కానీ ప్రోటోకాల్ రుసుము కొత్త ద్రవ్యత్వ టోకెన్లను మింట్ చేసి feeTo చిరునామాకు అందించాలి.

1                uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
2                uint rootKLast = Math.sqrt(_kLast);
3                if (rootK > rootKLast) {
కాపీ

ఒక ప్రోటోకాల్ రుసుమును వసూలు చేయడానికి కొత్త ద్రవ్యత ఉంటే. మీరు ఈ వ్యాసంలో తరువాత స్క్వేర్ రూట్ ఫంక్షన్ ను చూడవచ్చు (#Math)

1                    uint numerator = totalSupply.mul(rootK.sub(rootKLast));
2                    uint denominator = rootK.mul(5).add(rootKLast);
3                    uint liquidity = numerator / denominator;
కాపీ

రుసుముల యొక్క ఈ సంక్లిష్ట గణన వైట్‌పేపర్opens in a new tab లో 5వ పేజీలో వివరించబడింది. kLast లెక్కించబడిన సమయం మరియు ప్రస్తుతం మధ్య ద్రవ్యత జోడించబడలేదు లేదా తీసివేయబడలేదు అని మనకు తెలుసు (ఎందుకంటే ద్రవ్యత జోడించబడినప్పుడు లేదా తీసివేయబడినప్పుడు ప్రతిసారీ, అది వాస్తవంగా మారే ముందు ఈ గణనను మేము అమలు చేస్తాము), కాబట్టి reserve0 * reserve1 లో ఏదైనా మార్పు లావాదేవీ రుసుముల నుండి రావాలి (అవి లేకుండా మేము reserve0 * reserve1 ను స్థిరంగా ఉంచుతాము).

1                    if (liquidity > 0) _mint(feeTo, liquidity);
2                }
3            }
కాపీ

అదనపు ద్రవ్యత్వ టోకెన్లను వాస్తవంగా సృష్టించి, వాటిని feeTo కు కేటాయించడానికి UniswapV2ERC20._mint ఫంక్షన్ ను ఉపయోగించండి.

1        } else if (_kLast != 0) {
2            kLast = 0;
3        }
4    }
కాపీ

kLast కు రుసుము సెట్ చేయకపోతే దానిని సున్నాకు సెట్ చేయండి (ఒకవేళ అది ఇప్పటికే అలా లేకపోతే). ఈ ఒప్పందం వ్రాయబడినప్పుడు ఒక గ్యాస్ రీఫండ్ ఫీచర్opens in a new tab ఉండేది, ఇది ఒప్పందాలను వారు అవసరం లేని నిల్వను సున్నా చేయడం ద్వారా ఎథేరియం స్థితి యొక్క మొత్తం పరిమాణాన్ని తగ్గించడానికి ప్రోత్సహించింది. ఈ కోడ్ సాధ్యమైనప్పుడు ఆ రీఫండ్ ను పొందుతుంది.

బాహ్యంగా యాక్సెస్ చేయగల ఫంక్షన్లు

ఏదైనా లావాదేవీ లేదా ఒప్పందం ఈ ఫంక్షన్లను కాల్ చేయగలదు గమనించండి, అవి పెరిఫెరీ ఒప్పందం నుండి పిలవబడటానికి రూపొందించబడ్డాయి. మీరు వాటిని నేరుగా పిలిస్తే మీరు జత మార్పిడిని మోసం చేయలేరు, కానీ మీరు పొరపాటు ద్వారా విలువను కోల్పోవచ్చు.

మింట్

1    // ఈ తక్కువ-స్థాయి ఫంక్షన్ ముఖ్యమైన భద్రతా తనిఖీలను చేసే ఒప్పందం నుండి పిలవబడాలి
2    function mint(address to) external lock returns (uint liquidity) {
కాపీ

ఒక ద్రవ్యత్వ ప్రదాత పూల్ కు ద్రవ్యతను జోడించినప్పుడు ఈ ఫంక్షన్ పిలవబడుతుంది. ఇది రివార్డుగా అదనపు ద్రవ్యత్వ టోకెన్లను మింట్ చేస్తుంది. దీనిని పెరిఫెరీ ఒప్పందం నుండి పిలవాలి, ఇది అదే లావాదేవీలో ద్రవ్యతను జోడించిన తర్వాత దానిని పిలుస్తుంది (కాబట్టి చట్టబద్ధమైన యజమానికి ముందు కొత్త ద్రవ్యతను క్లెయిమ్ చేసే లావాదేవీని ఎవరూ సమర్పించలేరు).

1        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // గ్యాస్ పొదుపు
కాపీ

బహుళ విలువలను తిరిగి ఇచ్చే Solidity ఫంక్షన్ ఫలితాలను చదవడానికి ఇది విధానం. చివరిగా తిరిగి ఇచ్చిన విలువలను, బ్లాక్ టైమ్స్టాంప్ ను మేము విస్మరిస్తాము, ఎందుకంటే అది మాకు అవసరం లేదు.

1        uint balance0 = IERC20(token0).balanceOf(address(this));
2        uint balance1 = IERC20(token1).balanceOf(address(this));
3        uint amount0 = balance0.sub(_reserve0);
4        uint amount1 = balance1.sub(_reserve1);
కాపీ

ప్రస్తుత బ్యాలెన్స్ లను పొంది, ప్రతి టోకెన్ రకానికి ఎంత జోడించబడిందో చూడండి.

1        bool feeOn = _mintFee(_reserve0, _reserve1);
కాపీ

సేకరించవలసిన ప్రోటోకాల్ రుసుములను లెక్కించండి, ఒకవేళ ఉంటే, మరియు దానికి అనుగుణంగా ద్రవ్యత్వ టోకెన్లను మింట్ చేయండి. _mintFee పారామీటర్లు పాత నిల్వ విలువలు కాబట్టి, రుసుము కారణంగా పూల్ మార్పుల ఆధారంగా మాత్రమే రుసుము ఖచ్చితంగా లెక్కించబడుతుంది.

1        uint _totalSupply = totalSupply; // గ్యాస్ పొదుపు, totalSupply _mintFee లో అప్డేట్ కాగలదు కాబట్టి ఇక్కడ నిర్వచించాలి
2        if (_totalSupply == 0) {
3            liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
4           _mint(address(0), MINIMUM_LIQUIDITY); // మొదటి MINIMUM_LIQUIDITY టోకెన్లను శాశ్వతంగా లాక్ చేయండి
కాపీ

ఇది మొదటి డిపాజిట్ అయితే, MINIMUM_LIQUIDITY టోకెన్లను సృష్టించి, వాటిని లాక్ చేయడానికి చిరునామా సున్నాకు పంపండి. వాటిని ఎప్పటికీ విమోచించలేరు, అంటే పూల్ ఎప్పటికీ పూర్తిగా ఖాళీ చేయబడదు (ఇది కొన్ని చోట్ల సున్నాతో విభజన నుండి మనల్ని రక్షిస్తుంది). MINIMUM_LIQUIDITY విలువ వెయ్యి, ఇది చాలా ERC-20 లు ఒక టోకెన్ యొక్క 10^-18 వ యూనిట్లుగా విభజించబడ్డాయని పరిగణనలోకి తీసుకుంటే, ETH wei గా విభజించబడినట్లుగా, ఒకే టోకెన్ విలువకు 10^-15. అధిక ఖర్చు కాదు.

మొదటి డిపాజిట్ సమయంలో రెండు టోకెన్ల సాపేక్ష విలువ మనకు తెలియదు, కాబట్టి మేము మొత్తాలను గుణించి, డిపాజిట్ రెండు టోకెన్లలో సమాన విలువను అందిస్తుందని ఊహించి స్క్వేర్ రూట్ తీసుకుంటాము.

ఆర్బిట్రేజ్ వల్ల విలువను కోల్పోకుండా ఉండటానికి సమాన విలువను అందించడం డిపాజిటర్ ప్రయోజనం కాబట్టి మనం దీనిని నమ్మవచ్చు. రెండు టోకెన్ల విలువ ఒకేలా ఉందని అనుకుందాం, కానీ మన డిపాజిటర్ టోకెన్0 కంటే నాలుగు రెట్లు ఎక్కువ టోకెన్1 ని డిపాజిట్ చేసారు. ఒక వ్యాపారి టోకెన్0 విలువైనదని జత మార్పిడి భావించే వాస్తవాన్ని ఉపయోగించి దాని నుండి విలువను తీయవచ్చు.

మీరు చూడగలరు, వ్యాపారి అదనంగా 8 టోకెన్లను సంపాదించాడు, ఇది పూల్ విలువలో తగ్గుదల నుండి వస్తుంది, దాని యజమాని అయిన డిపాజిటర్ కు నష్టం కలిగిస్తుంది.

1        } else {
2            liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
కాపీ

ప్రతి తదుపరి డిపాజిట్ తో రెండు ఆస్తుల మధ్య మార్పిడి రేటు మనకు ఇప్పటికే తెలుసు, మరియు ద్రవ్యత్వ ప్రదాతలు రెండింటిలోనూ సమాన విలువను అందిస్తారని మేము ఆశిస్తున్నాము. వారు అలా చేయకపోతే, శిక్షగా వారు అందించిన తక్కువ విలువ ఆధారంగా మేము వారికి ద్రవ్యత్వ టోకెన్లను ఇస్తాము.

ఇది ప్రారంభ డిపాజిట్ అయినా లేదా తదుపరిది అయినా, మేము అందించే ద్రవ్యత్వ టోకెన్ల సంఖ్య reserve0*reserve1 లోని మార్పు యొక్క స్క్వేర్ రూట్ కు సమానం మరియు ద్రవ్యత్వ టోకెన్ విలువ మారదు (రెండు రకాల సమాన విలువలు లేని డిపాజిట్ ను మేము పొందితే తప్ప, ఆ సందర్భంలో "జరిమానా" పంపిణీ చేయబడుతుంది). ఇక్కడ అదే విలువ కలిగిన రెండు టోకెన్లతో మరొక ఉదాహరణ ఉంది, మూడు మంచి డిపాజిట్లు మరియు ఒకటి చెడ్డది (ఒకే టోకెన్ రకం డిపాజిట్, కాబట్టి ఇది ఏ ద్రవ్యత్వ టోకెన్లను ఉత్పత్తి చేయదు).

1        }
2        require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
3        _mint(to, liquidity);
కాపీ

అదనపు ద్రవ్యత్వ టోకెన్లను వాస్తవంగా సృష్టించి, సరైన ఖాతాకు ఇవ్వడానికి UniswapV2ERC20._mint ఫంక్షన్ ను ఉపయోగించండి.

1
2        _update(balance0, balance1, _reserve0, _reserve1);
3        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 మరియు reserve1 నవీకరించబడినవి
4        emit Mint(msg.sender, amount0, amount1);
5    }
కాపీ

స్థితి వేరియబుల్స్ (reserve0, reserve1, మరియు అవసరమైతే kLast) నవీకరించి, తగిన సంఘటనను విడుదల చేయండి.

బర్న్

1    // ఈ తక్కువ-స్థాయి ఫంక్షన్ ముఖ్యమైన భద్రతా తనిఖీలను చేసే ఒప్పందం నుండి పిలవబడాలి
2    function burn(address to) external lock returns (uint amount0, uint amount1) {
కాపీ

ద్రవ్యత ఉపసంహరించబడినప్పుడు మరియు తగిన ద్రవ్యత్వ టోకెన్లను బర్న్ చేయవలసినప్పుడు ఈ ఫంక్షన్ పిలవబడుతుంది. ఇది పెరిఫెరీ ఖాతా నుండి కూడా పిలవబడాలి.

1        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // గ్యాస్ పొదుపు
2        address _token0 = token0;                                // గ్యాస్ పొదుపు
3        address _token1 = token1;                                // గ్యాస్ పొదుపు
4        uint balance0 = IERC20(_token0).balanceOf(address(this));
5        uint balance1 = IERC20(_token1).balanceOf(address(this));
6        uint liquidity = balanceOf[address(this)];
కాపీ

పెరిఫెరీ ఒప్పందం కాల్ కు ముందు బర్న్ చేయవలసిన ద్రవ్యతను ఈ ఒప్పందానికి బదిలీ చేసింది. ఆ విధంగా ఎంత ద్రవ్యతను బర్న్ చేయాలో మనకు తెలుసు, మరియు అది బర్న్ అవుతుందని మనం నిర్ధారించుకోవచ్చు.

1        bool feeOn = _mintFee(_reserve0, _reserve1);
2        uint _totalSupply = totalSupply; // గ్యాస్ పొదుపు, totalSupply _mintFee లో నవీకరించగలదు కాబట్టి ఇక్కడ నిర్వచించాలి
3        amount0 = liquidity.mul(balance0) / _totalSupply; // బ్యాలెన్స్ లను ఉపయోగించడం ప్రో-రాటా పంపిణీని నిర్ధారిస్తుంది
4        amount1 = liquidity.mul(balance1) / _totalSupply; // బ్యాలెన్స్ లను ఉపయోగించడం ప్రో-రాటా పంపిణీని నిర్ధారిస్తుంది
5        require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
కాపీ

ద్రవ్యత్వ ప్రదాత రెండు టోకెన్ల సమాన విలువను పొందుతాడు. ఈ విధంగా మనం మార్పిడి రేటును మార్చము.

1        _burn(address(this), liquidity);
2        _safeTransfer(_token0, to, amount0);
3        _safeTransfer(_token1, to, amount1);
4        balance0 = IERC20(_token0).balanceOf(address(this));
5        balance1 = IERC20(_token1).balanceOf(address(this));
6
7        _update(balance0, balance1, _reserve0, _reserve1);
8        if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 మరియు reserve1 నవీకరించబడినవి
9        emit Burn(msg.sender, amount0, amount1, to);
10    }
11
అన్నీ చూపించు
కాపీ

burn ఫంక్షన్ యొక్క మిగిలిన భాగం పైన ఉన్న mint ఫంక్షన్ యొక్క ప్రతిబింబం.

స్వాప్

1    // ఈ తక్కువ-స్థాయి ఫంక్షన్ ముఖ్యమైన భద్రతా తనిఖీలను చేసే ఒప్పందం నుండి పిలవబడాలి
2    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
కాపీ

ఈ ఫంక్షన్ కూడా పెరిఫెరీ ఒప్పందం నుండి పిలవబడాలి.

1        require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
2        (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // గ్యాస్ పొదుపు
3        require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');
4
5        uint balance0;
6        uint balance1;
7        { // _token{0,1} కోసం స్కోప్, స్టాక్ చాలా లోతైన లోపాలను నివారిస్తుంది
కాపీ

స్థానిక వేరియబుల్స్ మెమరీలో లేదా, వాటి సంఖ్య చాలా ఎక్కువగా లేకపోతే, నేరుగా స్టాక్ మీద నిల్వ చేయబడతాయి. మనం స్టాక్ ను ఉపయోగించడానికి సంఖ్యను పరిమితం చేయగలిగితే మనం తక్కువ గ్యాస్ ను ఉపయోగిస్తాము. మరిన్ని వివరాల కోసం ఎల్లో పేపర్, అధికారిక Ethereum స్పెసిఫికేషన్లుopens in a new tab, p. 26, సమీకరణం 298 చూడండి.

1            address _token0 = token0;
2            address _token1 = token1;
3            require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
4            if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // ఆశాజనకంగా టోకెన్లను బదిలీ చేయండి
5            if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // ఆశాజనకంగా టోకెన్లను బదిలీ చేయండి
కాపీ

ఈ బదిలీ ఆశాజనకమైనది, ఎందుకంటే అన్ని షరతులు నెరవేరాయని మేము ఖచ్చితంగా తెలుసుకోకముందే మేము బదిలీ చేస్తాము. ఇది Ethereum లో సరే, ఎందుకంటే కాల్ లో తరువాత షరతులు నెరవేరకపోతే మేము దాని నుండి మరియు అది సృష్టించిన ఏవైనా మార్పుల నుండి తిరిగి వస్తాము.

1            if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
కాపీ

అభ్యర్థించినట్లయితే స్వాప్ గురించి స్వీకర్తకు తెలియజేయండి.

1            balance0 = IERC20(_token0).balanceOf(address(this));
2            balance1 = IERC20(_token1).balanceOf(address(this));
3        }
కాపీ

ప్రస్తుత బ్యాలెన్స్ లను పొందండి. పెరిఫెరీ ఒప్పందం స్వాప్ కోసం మమ్మల్ని పిలిచే ముందు టోకెన్లను మాకు పంపుతుంది. ఇది ఒప్పందానికి అది మోసం చేయబడలేదని తనిఖీ చేయడానికి సులభం చేస్తుంది, ఇది కోర్ ఒప్పందంలో జరగవలసిన తనిఖీ (ఎందుకంటే మా పెరిఫెరీ ఒప్పందం కంటే ఇతర సంస్థల నుండి మమ్మల్ని పిలవవచ్చు).

1        uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
2        uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
3        require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
4        { // reserve{0,1}Adjusted కోసం స్కోప్, స్టాక్ చాలా లోతైన లోపాలను నివారిస్తుంది
5            uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
6            uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
7            require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
కాపీ

ఇది స్వాప్ నుండి మనం నష్టపోకుండా చూసుకోవడానికి ఒక సానిటీ తనిఖీ. ఒక స్వాప్ reserve0*reserve1 ను తగ్గించే పరిస్థితి ఏదీ లేదు. ఇది కూడా స్వాప్ పై 0.3% రుసుము పంపబడుతుందని మేము నిర్ధారించుకునే చోట; K విలువను సానిటీ తనిఖీ చేసే ముందు, మేము రెండు బ్యాలెన్స్ లను 1000 తో గుణించి, మొత్తాలను 3 తో గుణించి తీసివేస్తాము, అంటే 0.3% (3/1000 = 0.003 = 0.3%) బ్యాలెన్స్ నుండి తీసివేయబడుతుంది, దాని K విలువను ప్రస్తుత నిల్వల K విలువతో పోల్చడానికి ముందు.

1        }
2
3        _update(balance0, balance1, _reserve0, _reserve1);
4        emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
5    }
కాపీ

reserve0 మరియు reserve1 ను నవీకరించండి, మరియు అవసరమైతే ధర సంచితాలు మరియు టైమ్ స్టాంప్ ను నవీకరించి, ఒక సంఘటనను విడుదల చేయండి.

సింక్ లేదా స్కిమ్

నిజమైన బ్యాలెన్స్ లు జత మార్పిడి భావించే నిల్వలతో సమకాలీకరణ కోల్పోవడం సాధ్యమే. ఒప్పందం యొక్క అనుమతి లేకుండా టోకెన్లను ఉపసంహరించుకోవడానికి మార్గం లేదు, కానీ డిపాజిట్లు వేరే విషయం. ఒక ఖాతా mint లేదా swap ను పిలవకుండానే మార్పిడికి టోకెన్లను బదిలీ చేయగలదు.

ఆ సందర్భంలో రెండు పరిష్కారాలు ఉన్నాయి:

• sync, నిల్వలను ప్రస్తుత బ్యాలెన్స్ లకు నవీకరించండి
• skim, అదనపు మొత్తాన్ని ఉపసంహరించుకోండి. టోకెన్లను ఎవరు డిపాజిట్ చేశారో మాకు తెలియదు కాబట్టి ఏ ఖాతానైనా skim ను పిలవడానికి అనుమతించబడుతుంది గమనించండి. ఈ సమాచారం ఒక సంఘటనలో విడుదల చేయబడుతుంది, కానీ సంఘటనలు బ్లాక్‌చెయిన్ నుండి అందుబాటులో ఉండవు.

1    // నిల్వలకు బ్యాలెన్స్ లను సరిపోల్చడానికి బలవంతం చేయండి
2    function skim(address to) external lock {
3        address _token0 = token0; // గ్యాస్ పొదుపు
4        address _token1 = token1; // గ్యాస్ పొదుపు
5        _safeTransfer(_token0, to, IERC20(_token0).balanceOf(address(this)).sub(reserve0));
6        _safeTransfer(_token1, to, IERC20(_token1).balanceOf(address(this)).sub(reserve1));
7    }
8
9
10
11    // నిల్వలను బ్యాలెన్స్ లకు సరిపోల్చడానికి బలవంతం చేయండి
12    function sync() external lock {
13        _update(IERC20(token0).balanceOf(address(this)), IERC20(token1).balanceOf(address(this)), reserve0, reserve1);
14    }
15}
అన్నీ చూపించు
కాపీ

UniswapV2Factory.sol

ఈ ఒప్పందంopens in a new tab జత మార్పిడులను సృష్టిస్తుంది.

1pragma solidity =0.5.16;
2
3import './interfaces/IUniswapV2Factory.sol';
4import './UniswapV2Pair.sol';
5
6contract UniswapV2Factory is IUniswapV2Factory {
7    address public feeTo;
8    address public feeToSetter;
కాపీ

ఈ స్థితి వేరియబుల్స్ ప్రోటోకాల్ రుసుమును అమలు చేయడానికి అవసరం (వైట్‌పేపర్opens in a new tab, p. 5 చూడండి). feeTo చిరునామా ప్రోటోకాల్ రుసుము కోసం ద్రవ్యత్వ టోకెన్లను సేకరిస్తుంది, మరియు feeToSetter feeTo ను వేరే చిరునామాకు మార్చడానికి అనుమతించబడిన చిరునామా.

1    mapping(address => mapping(address => address)) public getPair;
2    address[] public allPairs;
కాపీ

ఈ వేరియబుల్స్ జతలను, రెండు టోకెన్ రకాల మధ్య మార్పిడులను ట్రాక్ చేస్తాయి.

మొదటిది, getPair, ఇది రెండు ERC-20 టోకెన్లు మార్పిడి చేసే జత మార్పిడి ఒప్పందాన్ని గుర్తించే ఒక మ్యాపింగ్. ERC-20 టోకెన్లు వాటిని అమలు చేసే ఒప్పందాల చిరునామాల ద్వారా గుర్తించబడతాయి, కాబట్టి కీలు మరియు విలువ అన్నీ చిరునామాలే. tokenA నుండి tokenB కు మార్చడానికి అనుమతించే జత మార్పిడి చిరునామాను పొందడానికి, మీరు getPair[<tokenA address>][<tokenB address>] (లేదా ఇంకో విధంగా) ఉపయోగిస్తారు.

రెండవ వేరియబుల్, allPairs, ఈ ఫ్యాక్టరీ సృష్టించిన జత మార్పిడుల అన్ని చిరునామాలను కలిగి ఉన్న ఒక శ్రేణి. Ethereum లో మీరు ఒక మ్యాపింగ్ యొక్క కంటెంట్ పై మళ్ళింపు చేయలేరు, లేదా అన్ని కీ ల జాబితాను పొందలేరు, కాబట్టి ఈ ఫ్యాక్టరీ ఏ మార్పిడులను నిర్వహిస్తుందో తెలుసుకోవడానికి ఈ వేరియబుల్ మాత్రమే మార్గం.

గమనిక: మీరు ఒక మ్యాపింగ్ యొక్క అన్ని కీ లపై మళ్ళింపు చేయలేకపోవడానికి కారణం ఒప్పంద డేటా నిల్వ ఖరీదైనది, కాబట్టి దానిని తక్కువగా ఉపయోగించడం మరియు దానిని తక్కువగా మార్చడం మంచిది. మీరు మళ్ళింపుకు మద్దతు ఇచ్చే మ్యాపింగ్స్opens in a new tab ను సృష్టించవచ్చు, కానీ వాటికి కీ ల జాబితా కోసం అదనపు నిల్వ అవసరం. చాలా అప్లికేషన్లలో మీకు అది అవసరం లేదు.

1    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
కాపీ

ఒక కొత్త జత మార్పిడి సృష్టించబడినప్పుడు ఈ సంఘటన విడుదల చేయబడుతుంది. ఇది టోకెన్ల చిరునామాలు, జత మార్పిడి చిరునామా, మరియు ఫ్యాక్టరీ ద్వారా నిర్వహించబడే మొత్తం మార్పిడుల సంఖ్యను కలిగి ఉంటుంది.

1    constructor(address _feeToSetter) public {
2        feeToSetter = _feeToSetter;
3    }
కాపీ

నిర్మాణకర్త చేసే ఏకైక పని feeToSetter ను పేర్కొనడం. ఫ్యాక్టరీలు రుసుము లేకుండా ప్రారంభమవుతాయి, మరియు feeSetter మాత్రమే దానిని మార్చగలదు.

1    function allPairsLength() external view returns (uint) {
2        return allPairs.length;
3    }
కాపీ

ఈ ఫంక్షన్ మార్పిడి జతల సంఖ్యను తిరిగి ఇస్తుంది.

1    function createPair(address tokenA, address tokenB) external returns (address pair) {
కాపీ

ఇది ఫ్యాక్టరీ యొక్క ప్రధాన ఫంక్షన్, రెండు ERC-20 టోకెన్ల మధ్య జత మార్పిడిని సృష్టించడం. ఎవరైనా ఈ ఫంక్షన్ ను పిలవవచ్చు గమనించండి. కొత్త జత మార్పిడిని సృష్టించడానికి మీకు యూనిస్వాప్ నుండి అనుమతి అవసరం లేదు.

1        require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES');
2        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
కాపీ

మేము కొత్త మార్పిడి చిరునామాను డిటర్మినిస్టిక్ గా ఉండాలని కోరుకుంటున్నాము, కాబట్టి దానిని ముందుగానే ఆఫ్ చైన్ లో లెక్కించవచ్చు (ఇది /developers/docs/scaling/ లావాదేవీలకు ఉపయోగపడవచ్చు). దీనిని చేయడానికి, మనం వాటిని స్వీకరించిన క్రమంతో సంబంధం లేకుండా టోకెన్ చిరునామాల యొక్క స్థిరమైన క్రమాన్ని కలిగి ఉండాలి, కాబట్టి మనం వాటిని ఇక్కడ క్రమబద్ధీకరిస్తాము.

1        require(token0 != address(0), 'UniswapV2: ZERO_ADDRESS');
2        require(getPair[token0][token1] == address(0), 'UniswapV2: PAIR_EXISTS'); // ఒకే తనిఖీ సరిపోతుంది
కాపీ

చిన్న వాటి కంటే పెద్ద ద్రవ్యత్వ పూల్స్ మంచివి, ఎందుకంటే వాటికి మరింత స్థిరమైన ధరలు ఉంటాయి. మేము ప్రతి జత టోకెన్లకు ఒకే ద్రవ్యత్వ పూల్ కంటే ఎక్కువ ఉండకూడదని కోరుకుంటున్నాము. ఒకవేళ ఇప్పటికే ఒక మార్పిడి ఉంటే, అదే జత కోసం మరొకటి సృష్టించవలసిన అవసరం లేదు.

1        bytes memory bytecode = type(UniswapV2Pair).creationCode;
కాపీ

ఒక కొత్త ఒప్పందాన్ని సృష్టించడానికి మనకు దానిని సృష్టించే కోడ్ అవసరం (నిర్మాణకర్త ఫంక్షన్ మరియు అసలు ఒప్పందం యొక్క EVM బైట్కోడ్ ను మెమరీకి వ్రాసే కోడ్ రెండూ). సాధారణంగా Solidity లో మేము addr = new <name of contract>(<constructor parameters>) ను ఉపయోగిస్తాము మరియు కంపైలర్ మా కోసం అన్నింటినీ చూసుకుంటుంది, కానీ ఒక డిటర్మినిస్టిక్ ఒప్పంద చిరునామాను కలిగి ఉండటానికి మేము CREATE2 ఆప్కోడ్opens in a new tab ను ఉపయోగించాలి. ఈ కోడ్ వ్రాయబడినప్పుడు ఆ ఆప్కోడ్ ఇంకా Solidity ద్వారా మద్దతు ఇవ్వబడలేదు, కాబట్టి కోడ్ ను మాన్యువల్ గా పొందడం అవసరం. ఇది ఇప్పుడు సమస్య కాదు, ఎందుకంటే Solidity ఇప్పుడు CREATE2 కు మద్దతు ఇస్తుందిopens in a new tab.

1        bytes32 salt = keccak256(abi.encodePacked(token0, token1));
2        assembly {
3            pair := create2(0, add(bytecode, 32), mload(bytecode), salt)
4        }
కాపీ

ఒక ఆప్కోడ్ ఇంకా Solidity ద్వారా మద్దతు ఇవ్వబడనప్పుడు మనం దానిని ఇన్లైన్ అసెంబ్లీopens in a new tab ఉపయోగించి పిలవవచ్చు.

1        IUniswapV2Pair(pair).initialize(token0, token1);
కాపీ

కొత్త మార్పిడి ఏ రెండు టోకెన్లను మార్పిడి చేస్తుందో చెప్పడానికి initialize ఫంక్షన్ ను పిలవండి.

1        getPair[token0][token1] = pair;
2        getPair[token1][token0] = pair; // రివర్స్ దిశలో మ్యాపింగ్ నింపండి
3        allPairs.push(pair);
4        emit PairCreated(token0, token1, pair, allPairs.length);
కాపీ

కొత్త జత సమాచారాన్ని స్థితి వేరియబుల్స్ లో సేవ్ చేసి, కొత్త జత మార్పిడి గురించి ప్రపంచానికి తెలియజేయడానికి ఒక సంఘటనను విడుదల చేయండి.

1    function setFeeTo(address _feeTo) external {
2        require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
3        feeTo = _feeTo;
4    }
5
6    function setFeeToSetter(address _feeToSetter) external {
7        require(msg.sender == feeToSetter, 'UniswapV2: FORBIDDEN');
8        feeToSetter = _feeToSetter;
9    }
10}
అన్నీ చూపించు
కాపీ

ఈ రెండు ఫంక్షన్లు feeSetter రుసుము స్వీకర్తను (ఏదైనా ఉంటే) నియంత్రించడానికి మరియు feeSetter ను కొత్త చిరునామాకు మార్చడానికి అనుమతిస్తాయి.

UniswapV2ERC20.sol

ఈ ఒప్పందంopens in a new tab ERC-20 ద్రవ్యత్వ టోకెన్ ను అమలు చేస్తుంది. ఇది ఓపెన్జెప్పెలిన్ ERC-20 ఒప్పందం లాంటిది, కాబట్టి నేను భిన్నమైన భాగాన్ని, permit ఫంక్షనాలిటీని మాత్రమే వివరిస్తాను.

Ethereum పై లావాదేవీలకు ether (ETH) ఖర్చవుతుంది, ఇది నిజమైన డబ్బుతో సమానం. మీ దగ్గర ERC-20 టోకెన్లు ఉండి ETH లేకపోతే, మీరు లావాదేవీలను పంపలేరు, కాబట్టి మీరు వాటితో ఏమీ చేయలేరు. ఈ సమస్యను నివారించడానికి ఒక పరిష్కారం మెటా-లావాదేవీలుopens in a new tab. టోకెన్ల యజమాని టోకెన్లను ఆఫ్చైన్ ఉపసంహరించుకోవడానికి వేరొకరికి అనుమతించే లావాదేవీపై సంతకం చేసి, దానిని ఇంటర్నెట్ ద్వారా స్వీకర్తకు పంపుతాడు. ETH ఉన్న స్వీకర్త, యజమాని తరఫున అనుమతిని సమర్పిస్తాడు.

1    bytes32 public DOMAIN_SEPARATOR;
2    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
3    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
కాపీ

ఈ హాష్ లావాదేవీ రకం యొక్క ఐడెంటిఫైయర్opens in a new tab. మేము ఇక్కడ మద్దతు ఇచ్చే ఏకైక రకం Permit ఈ పారామీటర్లతో.

1    mapping(address => uint) public nonces;
కాపీ

ఒక స్వీకర్త డిజిటల్ సంతకాన్ని నకిలీ చేయడం అసాధ్యం. అయినప్పటికీ, అదే లావాదేవీని రెండుసార్లు పంపడం చాలా సులభం (ఇది రీప్లే అటాక్opens in a new tab యొక్క ఒక రూపం). దీనిని నివారించడానికి, మేము ఒక నోన్స్opens in a new tab ను ఉపయోగిస్తాము. ఒక కొత్త Permit యొక్క నోన్స్ చివరిగా ఉపయోగించిన దానికంటే ఒకటి ఎక్కువగా లేకపోతే, మేము దానిని చెల్లనిదిగా భావిస్తాము.

1    constructor() public {
2        uint chainId;
3        assembly {
4            chainId := chainid
5        }
కాపీ

ఇది చైన్ ఐడెంటిఫైయర్opens in a new tab ను తిరిగి పొందడానికి కోడ్. ఇది యూల్opens in a new tab అని పిలువబడే EVM అసెంబ్లీ మాండలికాన్ని ఉపయోగిస్తుంది. యూల్ యొక్క ప్రస్తుత వెర్షన్ లో మీరు chainid() ఉపయోగించాలని గమనించండి, chainid కాదు.

1        DOMAIN_SEPARATOR = keccak256(
2            abi.encode(
3                keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
4                keccak256(bytes(name)),
5                keccak256(bytes('1')),
6                chainId,
7                address(this)
8            )
9        );
10    }
అన్నీ చూపించు
కాపీ

EIP-712 కోసం డొమైన్ సెపరేటర్opens in a new tab ను లెక్కించండి.

1    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
కాపీ

అనుమతులను అమలు చేసే ఫంక్షన్ ఇది. ఇది పారామీటర్లుగా సంబంధిత ఫీల్డ్స్, మరియు సంతకంopens in a new tab (v, r, మరియు s) కోసం మూడు స్కేలార్ విలువలను స్వీకరిస్తుంది.

1        require(deadline >= block.timestamp, 'UniswapV2: EXPIRED');
కాపీ

గడువు తేదీ తర్వాత లావాదేవీలను అంగీకరించవద్దు.

1        bytes32 digest = keccak256(
2            abi.encodePacked(
3                '\x19\x01',
4                DOMAIN_SEPARATOR,
5                keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
6            )
7        );
కాపీ

abi.encodePacked(...) అనేది మేము పొందాలని ఆశించే సందేశం. నోన్స్ ఎలా ఉండాలో మనకు తెలుసు, కాబట్టి దానిని పారామీటర్ గా పొందాల్సిన అవసరం లేదు.

Ethereum సంతకం అల్గోరిథం సంతకం చేయడానికి 256 బిట్స్ పొందాలని ఆశిస్తుంది, కాబట్టి మేము keccak256 హాష్ ఫంక్షన్ ను ఉపయోగిస్తాము.

1        address recoveredAddress = ecrecover(digest, v, r, s);
కాపీ

డైజెస్ట్ మరియు సంతకం నుండి మనం దానిపై సంతకం చేసిన చిరునామాను ecrecoveropens in a new tab ఉపయోగించి పొందవచ్చు.

1        require(recoveredAddress != address(0) && recoveredAddress == owner, 'UniswapV2: INVALID_SIGNATURE');
2        _approve(owner, spender, value);
3    }
4
కాపీ

అన్నీ సరే అయితే, దీనిని ఒక ERC-20 ఆమోదంopens in a new tab గా పరిగణించండి.

పెరిఫెరీ ఒప్పందాలు

పెరిఫెరీ ఒప్పందాలు యూనిస్వాప్ కోసం API (అప్లికేషన్ ప్రోగ్రామ్ ఇంటర్ఫేస్). అవి ఇతర ఒప్పందాల నుండి లేదా వికేంద్రీకృత అప్లికేషన్ల నుండి బాహ్య కాల్స్ కోసం అందుబాటులో ఉన్నాయి. మీరు కోర్ ఒప్పందాలను నేరుగా పిలవవచ్చు, కానీ అది మరింత సంక్లిష్టంగా ఉంటుంది మరియు మీరు పొరపాటు చేస్తే విలువను కోల్పోవచ్చు. కోర్ ఒప్పందాలలో అవి మోసగించబడలేదని నిర్ధారించుకోవడానికి మాత్రమే పరీక్షలు ఉంటాయి, ఇతరుల కోసం సానిటీ తనిఖీలు ఉండవు. అవి పెరిఫెరీలో ఉన్నాయి కాబట్టి వాటిని అవసరమైనప్పుడు నవీకరించవచ్చు.

UniswapV2Router01.sol

ఈ ఒప్పందానికిopens in a new tab సమస్యలు ఉన్నాయి, మరియు ఇకపై ఉపయోగించకూడదుopens in a new tab. అదృష్టవశాత్తు, పెరిఫెరీ ఒప్పందాలు స్థితిరహితంగా ఉంటాయి మరియు ఏ ఆస్తులనూ కలిగి ఉండవు, కాబట్టి దానిని తొలగించి, బదులుగా UniswapV2Router02 ను ఉపయోగించమని ప్రజలకు సూచించడం సులభం.

UniswapV2Router02.sol

చాలా సందర్భాల్లో మీరు ఈ ఒప్పందంopens in a new tab ద్వారా యూనిస్వాప్ ను ఉపయోగిస్తారు. మీరు దానిని ఎలా ఉపయోగించాలో ఇక్కడopens in a new tab చూడవచ్చు.

1pragma solidity =0.6.6;
2
3import '@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol';
4import '@uniswap/lib/contracts/libraries/TransferHelper.sol';
5
6import './interfaces/IUniswapV2Router02.sol';
7import './libraries/UniswapV2Library.sol';
8import './libraries/SafeMath.sol';
9import './interfaces/IERC20.sol';
10import './interfaces/IWETH.sol';
అన్నీ చూపించు
కాపీ

వీటిలో చాలా వరకు మేము ఇంతకుముందు ఎదుర్కొన్నాము, లేదా చాలా స్పష్టంగా ఉన్నాయి. ఒక మినహాయింపు IWETH.sol. యూనిస్వాప్ v2 ఏ జత ERC-20 టోకెన్లకైనా మార్పిడులను అనుమతిస్తుంది, కానీ ether (ETH) స్వయంగా ERC-20 టోకెన్ కాదు. ఇది ప్రమాణానికి ముందుది మరియు ప్రత్యేక యంత్రాంగాల ద్వారా బదిలీ చేయబడుతుంది. ERC-20 టోకెన్లకు వర్తించే ఒప్పందాలలో ETH వాడకాన్ని ప్రారంభించడానికి ప్రజలు చుట్టబడిన ఈథర్ (WETH)opens in a new tab ఒప్పందంతో వచ్చారు. మీరు ఈ ఒప్పందానికి ETH ను పంపుతారు, మరియు అది మీకు సమానమైన WETH ను మింట్ చేస్తుంది. లేదా మీరు WETH ను బర్న్ చేసి, ETH ను తిరిగి పొందవచ్చు.

1contract UniswapV2Router02 is IUniswapV2Router02 {
2    using SafeMath for uint;
3
4    address public immutable override factory;
5    address public immutable override WETH;
కాపీ

రౌటర్ ఏ ఫ్యాక్టరీని ఉపయోగించాలో తెలుసుకోవాలి, మరియు WETH అవసరమయ్యే లావాదేవీల కోసం ఏ WETH ఒప్పందాన్ని ఉపయోగించాలో తెలుసుకోవాలి. ఈ విలువలు మార్పులేనివిopens in a new tab, అంటే అవి నిర్మాణకర్తలో మాత్రమే సెట్ చేయబడతాయి. ఇది వినియోగదారులకు వాటిని తక్కువ నిజాయితీ గల ఒప్పందాలకు మార్చడానికి ఎవరూ మార్చలేరనే విశ్వాసాన్ని ఇస్తుంది.

1    modifier ensure(uint deadline) {
2        require(deadline >= block.timestamp, 'UniswapV2Router: EXPIRED');
3        _;
4    }
కాపీ

ఈ మాడిఫైయర్ కాలపరిమితి గల లావాదేవీలు ("సమయం Y కంటే ముందు X చేయండి, ఒకవేళ వీలైతే") వాటి కాలపరిమితి తర్వాత జరగకుండా చూస్తుంది.

1    constructor(address _factory, address _WETH) public {
2        factory = _factory;
3        WETH = _WETH;
4    }
కాపీ

నిర్మాణకర్త మార్పులేని స్థితి వేరియబుల్స్ ను సెట్ చేస్తుంది.

1    receive() external payable {
2        assert(msg.sender == WETH); // WETH ఒప్పందం నుండి ఫాల్‌బ్యాక్ ద్వారా మాత్రమే ETH ని అంగీకరించండి
3    }
కాపీ

WETH ఒప్పందం నుండి టోకెన్లను తిరిగి ETH గా విమోచించుకున్నప్పుడు ఈ ఫంక్షన్ పిలవబడుతుంది. మేము ఉపయోగించే WETH ఒప్పందం మాత్రమే అలా చేయడానికి అధికారం కలిగి ఉంది.

ద్రవ్యతను జోడించండి

ఈ ఫంక్షన్లు జత మార్పిడికి టోకెన్లను జోడిస్తాయి, ఇది ద్రవ్యత్వ పూల్ ను పెంచుతుంది.

1
2    // **** ద్రవ్యతను జోడించండి ****
3    function _addLiquidity(
కాపీ

ఈ ఫంక్షన్ జత మార్పిడిలోకి డిపాజిట్ చేయవలసిన A మరియు B టోకెన్ల మొత్తాన్ని లెక్కించడానికి ఉపయోగించబడుతుంది.

1        address tokenA,
2        address tokenB,
కాపీ

ఇవి ERC-20 టోకెన్ ఒప్పందాల చిరునామాలు.

1        uint amountADesired,
2        uint amountBDesired,
కాపీ

ఇవి ద్రవ్యత్వ ప్రదాత డిపాజిట్ చేయాలనుకుంటున్న మొత్తాలు. ఇవి డిపాజిట్ చేయవలసిన గరిష్ట మొత్తాలు A మరియు B.

1        uint amountAMin,
2        uint amountBMin
కాపీ

ఇవి డిపాజిట్ చేయడానికి కనీస ఆమోదయోగ్యమైన మొత్తాలు. లావాదేవీ ఈ మొత్తాలతో లేదా అంతకంటే ఎక్కువతో జరగలేకపోతే, దాని నుండి తిరిగి రండి. మీకు ఈ ఫీచర్ వద్దనుకుంటే, కేవలం సున్నాను పేర్కొనండి.

ద్రవ్యత్వ ప్రదాతలు సాధారణంగా ఒక కనీస మొత్తాన్ని పేర్కొంటారు, ఎందుకంటే వారు లావాదేవీని ప్రస్తుత రేటుకు దగ్గరగా ఉండే మార్పిడి రేటుకు పరిమితం చేయాలనుకుంటారు. మార్పిడి రేటు చాలా ఎక్కువ హెచ్చుతగ్గులకు గురైతే, అది అంతర్లీన విలువలను మార్చే వార్తలను సూచిస్తుంది, మరియు వారు ఏమి చేయాలో మాన్యువల్ గా నిర్ణయించుకోవాలనుకుంటారు.

ఉదాహరణకు, మార్పిడి రేటు ఒకటికి ఒకటిగా ఉన్న ఒక సందర్భాన్ని ఊహించండి మరియు ద్రవ్యత్వ ప్రదాత ఈ విలువలను పేర్కొంటారు:

మార్పిడి రేటు 0.9 మరియు 1.25 మధ్య ఉన్నంత కాలం, లావాదేవీ జరుగుతుంది. మార్పిడి రేటు ఆ పరిధి నుండి బయటకు వెళితే, లావాదేవీ రద్దు చేయబడుతుంది.

ఈ జాగ్రత్తకు కారణం లావాదేవీలు తక్షణమే జరగవు, మీరు వాటిని సమర్పిస్తారు మరియు చివరికి ఒక ధృవీకరణకర్త వాటిని ఒక బ్లాక్‌లో చేర్చబోతున్నాడు (మీ గ్యాస్ ధర చాలా తక్కువగా ఉంటే తప్ప, ఆ సందర్భంలో మీరు దానిని ఓవర్‌రైట్ చేయడానికి అదే నోన్స్ మరియు అధిక గ్యాస్ ధరతో మరొక లావాదేవీని సమర్పించవలసి ఉంటుంది). సమర్పణ మరియు చేర్పు మధ్య వ్యవధిలో ఏమి జరుగుతుందో మీరు నియంత్రించలేరు.

1    ) internal virtual returns (uint amountA, uint amountB) {
కాపీ

ద్రవ్యత్వ ప్రదాత నిల్వల మధ్య ప్రస్తుత నిష్పత్తికి సమానమైన నిష్పత్తిని కలిగి ఉండటానికి డిపాజిట్ చేయవలసిన మొత్తాలను ఫంక్షన్ తిరిగి ఇస్తుంది.

1        // ఇంకా జత లేకపోతే దాన్ని సృష్టించండి
2        if (IUniswapV2Factory(factory).getPair(tokenA, tokenB) == address(0)) {
3            IUniswapV2Factory(factory).createPair(tokenA, tokenB);
4        }
కాపీ

ఈ టోకెన్ జత కోసం ఇంకా మార్పిడి లేకపోతే, దానిని సృష్టించండి.

1        (uint reserveA, uint reserveB) = UniswapV2Library.getReserves(factory, tokenA, tokenB);
కాపీ

జతలో ప్రస్తుత నిల్వలను పొందండి.

1        if (reserveA == 0 && reserveB == 0) {
2            (amountA, amountB) = (amountADesired, amountBDesired);
కాపీ

ప్రస్తుత నిల్వలు ఖాళీగా ఉంటే ఇది కొత్త జత మార్పిడి. డిపాజిట్ చేయవలసిన మొత్తాలు ద్రవ్యత్వ ప్రదాత అందించాలనుకుంటున్న వాటికి సరిగ్గా సమానంగా ఉండాలి.

1        } else {
2            uint amountBOptimal = UniswapV2Library.quote(amountADesired, reserveA, reserveB);
కాపీ

మొత్తాలు ఎలా ఉంటాయో చూడాలనుకుంటే, మేము ఈ ఫంక్షన్opens in a new tab ఉపయోగించి ఉత్తమమైన మొత్తాన్ని పొందుతాము. మేము ప్రస్తుత నిల్వల మాదిరిగానే నిష్పత్తిని కోరుకుంటున్నాము.

1            if (amountBOptimal <= amountBDesired) {
2                require(amountBOptimal >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
3                (amountA, amountB) = (amountADesired, amountBOptimal);
కాపీ

amountBOptimal ద్రవ్యత్వ ప్రదాత డిపాజిట్ చేయాలనుకుంటున్న మొత్తం కంటే తక్కువగా ఉంటే, టోకెన్ B ప్రస్తుతం ద్రవ్యత్వ డిపాజిటర్ భావించే దానికంటే ఎక్కువ విలువైనదని అర్థం, కాబట్టి తక్కువ మొత్తం అవసరం.

1            } else {
2                uint amountAOptimal = UniswapV2Library.quote(amountBDesired, reserveB, reserveA);
3                assert(amountAOptimal <= amountADesired);
4                require(amountAOptimal >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
5                (amountA, amountB) = (amountAOptimal, amountBDesired);
కాపీ

ఉత్తమ B మొత్తం కోరిన B మొత్తం కంటే ఎక్కువగా ఉంటే, B టోకెన్లు ప్రస్తుతం ద్రవ్యత్వ డిపాజిటర్ భావించే దానికంటే తక్కువ విలువైనవని అర్థం, కాబట్టి అధిక మొత్తం అవసరం. అయినప్పటికీ, కోరిన మొత్తం గరిష్టంగా ఉంటుంది, కాబట్టి మేము అలా చేయలేము. బదులుగా మేము కోరిన B టోకెన్ల మొత్తానికి ఉత్తమమైన A టోకెన్ల సంఖ్యను లెక్కించుకుంటాము.

అన్నింటినీ కలిపి మనం ఈ గ్రాఫ్ ను పొందుతాము. మీరు వెయ్యి A టోకెన్లు (నీలి గీత) మరియు వెయ్యి B టోకెన్లు (ఎరుపు గీత) డిపాజిట్ చేయడానికి ప్రయత్నిస్తున్నారని అనుకుందాం. x అక్షం మార్పిడి రేటు, A/B. x=1 అయితే, అవి విలువలో సమానంగా ఉంటాయి మరియు మీరు ప్రతి దాని నుండి వెయ్యి డిపాజిట్ చేస్తారు. x=2 అయితే, A విలువ B కంటే రెండు రెట్లు ఎక్కువ (ప్రతి A టోకెన్ కు రెండు B టోకెన్లు పొందుతారు) కాబట్టి మీరు వెయ్యి B టోకెన్లను డిపాజిట్ చేస్తారు, కానీ కేవలం 500 A టోకెన్లను మాత్రమే. x=0.5 అయితే, పరిస్థితి రివర్స్ అవుతుంది, వెయ్యి A టోకెన్లు మరియు ఐదు వందల B టోకెన్లు.

మీరు ద్రవ్యతను నేరుగా కోర్ ఒప్పందంలోకి డిపాజిట్ చేయవచ్చు ( UniswapV2Pair::mintopens in a new tab ఉపయోగించి), కానీ కోర్ ఒప్పందం అది మోసగించబడలేదని మాత్రమే తనిఖీ చేస్తుంది, కాబట్టి మీరు మీ లావాదేవీని సమర్పించిన సమయం మరియు అది అమలు చేయబడిన సమయం మధ్య మార్పిడి రేటు మారితే మీరు విలువను కోల్పోయే ప్రమాదం ఉంది. మీరు పెరిఫెరీ ఒప్పందాన్ని ఉపయోగిస్తే, అది మీరు డిపాజిట్ చేయవలసిన మొత్తాన్ని లెక్కిస్తుంది మరియు దానిని వెంటనే డిపాజిట్ చేస్తుంది, కాబట్టి మార్పిడి రేటు మారదు మరియు మీరు ఏమీ కోల్పోరు.

1    function addLiquidity(
2        address tokenA,
3        address tokenB,
4        uint amountADesired,
5        uint amountBDesired,
6        uint amountAMin,
7        uint amountBMin,
8        address to,
9        uint deadline
అన్నీ చూపించు
కాపీ

ఈ ఫంక్షన్ ద్రవ్యతను డిపాజిట్ చేయడానికి ఒక లావాదేవీ ద్వారా పిలవబడవచ్చు. చాలా పారామీటర్లు పైన ఉన్న _addLiquidity లోని వాటితో సమానంగా ఉంటాయి, రెండు మినహాయింపులతో:

. to అనేది ద్రవ్యత్వ ప్రదాత యొక్క పూల్ లోని వాటాను చూపించడానికి ముద్రించబడిన కొత్త ద్రవ్యత్వ టోకెన్లను పొందే చిరునామా . deadline అనేది లావాదేవీపై ఒక కాలపరిమితి

1    ) external virtual override ensure(deadline) returns (uint amountA, uint amountB, uint liquidity) {
2        (amountA, amountB) = _addLiquidity(tokenA, tokenB, amountADesired, amountBDesired, amountAMin, amountBMin);
3        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
కాపీ

మేము వాస్తవంగా డిపాజిట్ చేయవలసిన మొత్తాలను లెక్కిస్తాము, ఆపై ద్రవ్యత్వ పూల్ యొక్క చిరునామాను కనుగొంటాము. గ్యాస్ ఆదా చేయడానికి మేము ఫ్యాక్టరీని అడగడం ద్వారా ఇది చేయము, కానీ లైబ్రరీ ఫంక్షన్ pairFor (లైబ్రరీలలో క్రింద చూడండి) ను ఉపయోగిస్తాము.

1        TransferHelper.safeTransferFrom(tokenA, msg.sender, pair, amountA);
2        TransferHelper.safeTransferFrom(tokenB, msg.sender, pair, amountB);
కాపీ

వినియోగదారు నుండి సరైన మొత్తంలో టోకెన్లను జత మార్పిడిలోకి బదిలీ చేయండి.

1        liquidity = IUniswapV2Pair(pair).mint(to);
కాపీ

ప్రతిఫలంగా to చిరునామాకు పూల్ లో పాక్షిక యాజమాన్యం కోసం ద్రవ్యత్వ టోకెన్లను ఇవ్వండి. కోర్ ఒప్పందం యొక్క mint ఫంక్షన్ దాని వద్ద ఎన్ని అదనపు టోకెన్లు ఉన్నాయో చూస్తుంది (ద్రవ్యత చివరిసారి మారినప్పుడు దాని వద్ద ఉన్న దానితో పోలిస్తే) మరియు దానికి అనుగుణంగా ద్రవ్యతను మింట్ చేస్తుంది.

1    function addLiquidityETH(
2        address token,
3        uint amountTokenDesired,
కాపీ

ఒక ద్రవ్యత్వ ప్రదాత టోకెన్/ETH జత మార్పిడికి ద్రవ్యతను అందించాలనుకున్నప్పుడు, కొన్ని తేడాలు ఉన్నాయి. ద్రవ్యత్వ ప్రదాత కోసం ETH ను చుట్టే పనిని ఒప్పందం నిర్వహిస్తుంది. వినియోగదారు ఎన్ని ETH డిపాజిట్ చేయాలనుకుంటున్నారో పేర్కొనవలసిన అవసరం లేదు, ఎందుకంటే వినియోగదారు వాటిని లావాదేవీతో పంపుతారు (మొత్తం msg.value లో అందుబాటులో ఉంటుంది).

1        uint amountTokenMin,
2        uint amountETHMin,
3        address to,
4        uint deadline
5    ) external virtual override payable ensure(deadline) returns (uint amountToken, uint amountETH, uint liquidity) {
6        (amountToken, amountETH) = _addLiquidity(
7            token,
8            WETH,
9            amountTokenDesired,
10            msg.value,
11            amountTokenMin,
12            amountETHMin
13        );
14        address pair = UniswapV2Library.pairFor(factory, token, WETH);
15        TransferHelper.safeTransferFrom(token, msg.sender, pair, amountToken);
16        IWETH(WETH).deposit{value: amountETH}();
17        assert(IWETH(WETH).transfer(pair, amountETH));
అన్నీ చూపించు
కాపీ

ETH ను డిపాజిట్ చేయడానికి ఒప్పందం మొదట దానిని WETH గా చుట్టి, ఆపై WETH ను జతలోకి బదిలీ చేస్తుంది. బదిలీ assert లో చుట్టబడిందని గమనించండి. దీని అర్థం బదిలీ విఫలమైతే ఈ ఒప్పంద కాల్ కూడా విఫలమవుతుంది, అందువల్ల చుట్టేది వాస్తవంగా జరగదు.

1        liquidity = IUniswapV2Pair(pair).mint(to);
2        // దుమ్ము ఈథర్ ను తిరిగి చెల్లించండి, ఏదైనా ఉంటే
3        if (msg.value > amountETH) TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH);
కాపీ

వినియోగదారు మాకు ఇప్పటికే ETH ను పంపారు, కాబట్టి ఏదైనా అదనంగా మిగిలి ఉంటే (ఎందుకంటే ఇతర టోకెన్ వినియోగదారు భావించిన దానికంటే తక్కువ విలువైనది), మేము వాపసు జారీ చేయాలి.

ద్రవ్యతను తొలగించండి

ఈ ఫంక్షన్లు ద్రవ్యతను తొలగించి, ద్రవ్యత్వ ప్రదాతకు తిరిగి చెల్లిస్తాయి.

1    // **** ద్రవ్యతను తొలగించండి ****
2    function removeLiquidity(
3        address tokenA,
4        address tokenB,
5        uint liquidity,
6        uint amountAMin,
7        uint amountBMin,
8        address to,
9        uint deadline
10    ) public virtual override ensure(deadline) returns (uint amountA, uint amountB) {
అన్నీ చూపించు
కాపీ

ద్రవ్యతను తొలగించే అత్యంత సులభమైన సందర్భం. ద్రవ్యత్వ ప్రదాత అంగీకరించడానికి ప్రతి టోకెన్ యొక్క కనీస మొత్తం ఉంది, మరియు అది గడువు తేదీకి ముందు జరగాలి.

1        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
2        IUniswapV2Pair(pair).transferFrom(msg.sender, pair, liquidity); // ద్రవ్యతను జతకు పంపండి
3        (uint amount0, uint amount1) = IUniswapV2Pair(pair).burn(to);
కాపీ

కోర్ ఒప్పందం యొక్క burn ఫంక్షన్ వినియోగదారుకు టోకెన్లను తిరిగి చెల్లించే పనిని నిర్వహిస్తుంది.

1        (address token0,) = UniswapV2Library.sortTokens(tokenA, tokenB);
కాపీ

ఒక ఫంక్షన్ బహుళ విలువలను తిరిగి ఇచ్చినప్పుడు, కానీ మనం వాటిలో కొన్నింటిపై మాత్రమే ఆసక్తి కలిగి ఉన్నప్పుడు, మనం ఆ విలువలను మాత్రమే పొందే విధానం ఇది. ఒక విలువను చదివి ఎప్పుడూ ఉపయోగించకపోవడం కంటే గ్యాస్ పరంగా ఇది కొంత చౌకైనది.

1        (amountA, amountB) = tokenA == token0 ? (amount0, amount1) : (amount1, amount0);
కాపీ

కోర్ ఒప్పందం వాటిని తిరిగి ఇచ్చే విధానం (తక్కువ చిరునామా టోకెన్ మొదట) నుండి వినియోగదారు వాటిని ఆశించే విధానానికి (tokenA మరియు tokenB కు అనుగుణంగా) మొత్తాలను అనువదించండి.

1        require(amountA >= amountAMin, 'UniswapV2Router: INSUFFICIENT_A_AMOUNT');
2        require(amountB >= amountBMin, 'UniswapV2Router: INSUFFICIENT_B_AMOUNT');
3    }
కాపీ

మొదట బదిలీ చేసి, ఆపై అది చట్టబద్ధమైనదేనా అని ధృవీకరించడం సరే, ఎందుకంటే అది కాకపోతే మనం అన్ని స్థితి మార్పుల నుండి తిరిగి వస్తాము.

1    function removeLiquidityETH(
2        address token,
3        uint liquidity,
4        uint amountTokenMin,
5        uint amountETHMin,
6        address to,
7        uint deadline
8    ) public virtual override ensure(deadline) returns (uint amountToken, uint amountETH) {
9        (amountToken, amountETH) = removeLiquidity(
10            token,
11            WETH,
12            liquidity,
13            amountTokenMin,
14            amountETHMin,
15            address(this),
16            deadline
17        );
18        TransferHelper.safeTransfer(token, to, amountToken);
19        IWETH(WETH).withdraw(amountETH);
20        TransferHelper.safeTransferETH(to, amountETH);
21    }
అన్నీ చూపించు
కాపీ

ETH కోసం ద్రవ్యతను తొలగించడం దాదాపు అదే, కానీ మేము WETH టోకెన్లను స్వీకరించి, ఆపై వాటిని ETH కోసం విమోచించి, ద్రవ్యత్వ ప్రదాతకు తిరిగి ఇస్తాము.

1    function removeLiquidityWithPermit(
2        address tokenA,
3        address tokenB,
4        uint liquidity,
5        uint amountAMin,
6        uint amountBMin,
7        address to,
8        uint deadline,
9        bool approveMax, uint8 v, bytes32 r, bytes32 s
10    ) external virtual override returns (uint amountA, uint amountB) {
11        address pair = UniswapV2Library.pairFor(factory, tokenA, tokenB);
12        uint value = approveMax ? uint(-1) : liquidity;
13        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
14        (amountA, amountB) = removeLiquidity(tokenA, tokenB, liquidity, amountAMin, amountBMin, to, deadline);
15    }
16
17
18    function removeLiquidityETHWithPermit(
19        address token,
20        uint liquidity,
21        uint amountTokenMin,
22        uint amountETHMin,
23        address to,
24        uint deadline,
25        bool approveMax, uint8 v, bytes32 r, bytes32 s
26    ) external virtual override returns (uint amountToken, uint amountETH) {
27        address pair = UniswapV2Library.pairFor(factory, token, WETH);
28        uint value = approveMax ? uint(-1) : liquidity;
29        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
30        (amountToken, amountETH) = removeLiquidityETH(token, liquidity, amountTokenMin, amountETHMin, to, deadline);
31    }
అన్నీ చూపించు
కాపీ

ఈ ఫంక్షన్లు ఈథర్ లేని వినియోగదారులను పూల్ నుండి ఉపసంహరించుకోవడానికి మెటా-లావాదేవీలను రిలే చేస్తాయి, అనుమతి యంత్రాంగం ను ఉపయోగిస్తాయి.

1
2    // **** ద్రవ్యతను తొలగించండి (రుసుము-బదిలీ టోకెన్లకు మద్దతు ఇస్తుంది) ****
3    function removeLiquidityETHSupportingFeeOnTransferTokens(
4        address token,
5        uint liquidity,
6        uint amountTokenMin,
7        uint amountETHMin,
8        address to,
9        uint deadline
10    ) public virtual override ensure(deadline) returns (uint amountETH) {
11        (, amountETH) = removeLiquidity(
12            token,
13            WETH,
14            liquidity,
15            amountTokenMin,
16            amountETHMin,
17            address(this),
18            deadline
19        );
20        TransferHelper.safeTransfer(token, to, IERC20(token).balanceOf(address(this)));
21        IWETH(WETH).withdraw(amountETH);
22        TransferHelper.safeTransferETH(to, amountETH);
23    }
24
అన్నీ చూపించు
కాపీ

బదిలీ లేదా నిల్వ రుసుములు ఉన్న టోకెన్ల కోసం ఈ ఫంక్షన్ ను ఉపయోగించవచ్చు. ఒక టోకెన్ కు అలాంటి రుసుములు ఉన్నప్పుడు, మేము ఎంత టోకెన్ తిరిగి పొందాలో చెప్పడానికి removeLiquidity ఫంక్షన్ పై ఆధారపడలేము, కాబట్టి మేము మొదట ఉపసంహరించుకుని, ఆపై బ్యాలెన్స్ ను పొందాలి.

1
2
3    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
4        address token,
5        uint liquidity,
6        uint amountTokenMin,
7        uint amountETHMin,
8        address to,
9        uint deadline,
10        bool approveMax, uint8 v, bytes32 r, bytes32 s
11    ) external virtual override returns (uint amountETH) {
12        address pair = UniswapV2Library.pairFor(factory, token, WETH);
13        uint value = approveMax ? uint(-1) : liquidity;
14        IUniswapV2Pair(pair).permit(msg.sender, address(this), value, deadline, v, r, s);
15        amountETH = removeLiquidityETHSupportingFeeOnTransferTokens(
16            token, liquidity, amountTokenMin, amountETHMin, to, deadline
17        );
18    }
అన్నీ చూపించు
కాపీ