Uniswap-v2 কন্ট্রাক্ট ওয়াক-থ্রু

ভূমিকা

Uniswap v2 (opens in a new tab) যেকোনো দুটি ERC-20 টোকেনের মধ্যে একটি এক্সচেঞ্জ মার্কেট তৈরি করতে পারে। এই আর্টিকেলে আমরা এই প্রটোকলটি ইমপ্লিমেন্ট করা কন্ট্রাক্টগুলোর সোর্স কোড নিয়ে আলোচনা করব এবং দেখব কেন সেগুলো এভাবে লেখা হয়েছে।

Uniswap কী করে?

মূলত, দুই ধরনের ব্যবহারকারী রয়েছে: লিকুইডিটি প্রোভাইডার এবং ট্রেডার।

লিকুইডিটি প্রোভাইডাররা পুলটিতে দুটি টোকেন প্রদান করে যা এক্সচেঞ্জ করা যায় (আমরা সেগুলোকে Token0 এবং Token1 বলব)। এর বিনিময়ে, তারা তৃতীয় একটি টোকেন পায় যা পুলের আংশিক মালিকানাকে উপস্থাপন করে, যাকে লিকুইডিটি টোকেন বলা হয়।

ট্রেডাররা পুলে এক ধরনের টোকেন পাঠায় এবং লিকুইডিটি প্রোভাইডারদের দেওয়া পুল থেকে অন্যটি গ্রহণ করে (উদাহরণস্বরূপ, Token0 পাঠায় এবং Token1 গ্রহণ করে)। এক্সচেঞ্জ রেট নির্ধারিত হয় পুলে থাকা Token0 এবং Token1 এর আপেক্ষিক সংখ্যার ওপর ভিত্তি করে। এছাড়া, পুলটি লিকুইডিটি পুলের জন্য রিওয়ার্ড হিসেবে একটি ছোট শতাংশ কেটে নেয়।

লিকুইডিটি প্রোভাইডাররা যখন তাদের সম্পদ ফেরত পেতে চায়, তখন তারা পুল টোকেনগুলো বার্ন করতে পারে এবং রিওয়ার্ডের অংশসহ তাদের টোকেনগুলো ফেরত পেতে পারে।

আরও বিস্তারিত বর্ণনার জন্য এখানে ক্লিক করুন (opens in a new tab)।

কেন v2? কেন v3 নয়?

Uniswap v3 (opens in a new tab) হলো একটি আপগ্রেড যা v2 এর চেয়ে অনেক বেশি জটিল। প্রথমে v2 শেখা এবং তারপর v3 তে যাওয়া বেশি সহজ।

কোর কন্ট্রাক্ট বনাম পেরিফেরি কন্ট্রাক্ট

Uniswap v2 দুটি উপাদানে বিভক্ত, একটি কোর এবং একটি পেরিফেরি। এই বিভাজন কোর কন্ট্রাক্টগুলোকে, যা সম্পদ ধারণ করে এবং তাই সেগুলোকে সুরক্ষিত হতেই হবে, আরও সহজ এবং অডিট করার জন্য সুবিধাজনক করে তোলে। ট্রেডারদের জন্য প্রয়োজনীয় সমস্ত অতিরিক্ত কার্যকারিতা এরপর পেরিফেরি কন্ট্রাক্টগুলোর মাধ্যমে প্রদান করা যেতে পারে।

ডাটা এবং কন্ট্রোল ফ্লো

ইউনিসোয়াপের (Uniswap) তিনটি প্রধান কাজ করার সময় ডাটা এবং কন্ট্রোলের ফ্লো যেভাবে কাজ করে:

1. বিভিন্ন টোকেনের মধ্যে সোয়াপ করা
2. মার্কেটে লিকুইডিটি যোগ করা এবং পেয়ার এক্সচেঞ্জ ERC-20 লিকুইডিটি টোকেন দিয়ে পুরস্কৃত হওয়া
3. ERC-20 লিকুইডিটি টোকেন বার্ন করা এবং সেই ERC-20 টোকেনগুলো ফেরত পাওয়া যা পেয়ার এক্সচেঞ্জ ট্রেডারদের এক্সচেঞ্জ করার অনুমতি দেয়

সোয়াপ

এটি সবচেয়ে সাধারণ ফ্লো, যা ট্রেডাররা ব্যবহার করে থাকেন:

কলার

1. পেরিফেরি একাউন্টকে সোয়াপ করার পরিমাণের একটি এলাউন্স প্রদান করুন।
2. পেরিফেরি কন্ট্রাক্টের অনেকগুলো সোয়াপ ফাংশনের মধ্যে একটি কল করুন (কোনটি কল করবেন তা নির্ভর করে ETH জড়িত আছে কি না, ট্রেডার জমা দেওয়ার টোকেনের পরিমাণ বা ফেরত পাওয়ার টোকেনের পরিমাণ নির্দিষ্ট করেছেন কি না, ইত্যাদির ওপর)। প্রতিটি সোয়াপ ফাংশন একটি path গ্রহণ করে, যা হলো অতিক্রম করার জন্য এক্সচেঞ্জগুলোর একটি অ্যারে।

পেরিফেরি কন্ট্রাক্টে (UniswapV2Router02.sol)

3. পাথের প্রতিটি এক্সচেঞ্জে ট্রেড করার পরিমাণগুলো চিহ্নিত করুন।
4. পাথের ওপর ইটারেট করে। পথের প্রতিটি এক্সচেঞ্জের জন্য এটি ইনপুট টোকেন পাঠায় এবং তারপর এক্সচেঞ্জের swap ফাংশন কল করে। বেশিরভাগ ক্ষেত্রে টোকেনগুলোর গন্তব্য এডড্রেস হলো পাথের পরবর্তী পেয়ার এক্সচেঞ্জ। চূড়ান্ত এক্সচেঞ্জে এটি ট্রেডারের দেওয়া এডড্রেস হয়।

কোর কন্ট্রাক্টে (UniswapV2Pair.sol)

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 A টোকেন, 500 B টোকেন এবং 90 লিকুইডিটি টোকেন থাকে এবং আমরা বার্ন করার জন্য 9 টোকেন পাই, তবে আমরা 10% লিকুইডিটি টোকেন বার্ন করছি, তাই আমরা ব্যবহারকারীকে 100 A টোকেন এবং 50 B টোকেন ফেরত পাঠাব।
5. লিকুইডিটি টোকেনগুলো বার্ন করুন
6. রিজার্ভের পরিমাণ আপডেট করতে _update কল করুন

মূল কন্ট্রাক্টস

এগুলো হলো সুরক্ষিত কন্ট্রাক্ট যা লিকুইডিটি ধরে রাখে।

UniswapV2Pair.sol

এই কন্ট্রাক্টটি (opens in a new tab) আসল পুলটি বাস্তবায়ন করে যা টোকেন এক্সচেঞ্জ করে। এটি Uniswap-এর মূল কার্যকারিতা।

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;
কপি করুন

ওভারফ্লো এবং আন্ডারফ্লো এড়াতে SafeMath লাইব্রেরি (opens in a new tab) ব্যবহার করা হয়। এটি গুরুত্বপূর্ণ কারণ অন্যথায় আমরা এমন একটি পরিস্থিতিতে পড়তে পারি যেখানে একটি মান -1 হওয়া উচিত, কিন্তু তার বদলে সেটি 2^256-1 হয়ে যায়।

1    using UQ112x112 for uint224;
কপি করুন

পুল কন্ট্রাক্টের অনেক হিসাবের জন্য ভগ্নাংশের প্রয়োজন হয়। তবে, EVM ভগ্নাংশ সমর্থন করে না। Uniswap এর যে সমাধানটি বের করেছে তা হলো 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 এর মাধ্যমে অ্যাক্সেসযোগ্য
কপি করুন

প্রতিটি টোকেন টাইপের জন্য পুলের যে রিজার্ভ রয়েছে। আমরা ধরে নিই যে দুটি একই পরিমাণ মান উপস্থাপন করে, এবং তাই প্রতিটি token0-এর মান reserve1/reserve0 সংখ্যক token1-এর সমান।

1    uint32  private blockTimestampLast; // সিঙ্গেল স্টোরেজ স্লট ব্যবহার করে, যা getReserves এর মাধ্যমে অ্যাক্সেসযোগ্য
কপি করুন

সর্বশেষ যে ব্লক-এ একটি এক্সচেঞ্জ ঘটেছিল তার টাইমস্ট্যাম্প, যা সময়ের সাথে সাথে এক্সচেঞ্জ রেট ট্র্যাক করতে ব্যবহৃত হয়।

ইথিরিয়াম কন্ট্রাক্টগুলোর সবচেয়ে বড় গ্যাস খরচের একটি হলো স্টোরেজ, যা কন্ট্রাক্টের এক কল থেকে পরের কল পর্যন্ত স্থায়ী হয়। প্রতিটি স্টোরেজ সেল 256 বিট দীর্ঘ। তাই তিনটি ভেরিয়েবল, reserve0, reserve1, এবং blockTimestampLast, এমনভাবে বরাদ্দ করা হয় যাতে একটি একক স্টোরেজ মান তাদের তিনটিকে অন্তর্ভুক্ত করতে পারে (112+112+32=256)।

1    uint public price0CumulativeLast;
2    uint public price1CumulativeLast;
কপি করুন

এই ভেরিয়েবলগুলো প্রতিটি টোকেনের জন্য ক্রমবর্ধমান খরচ ধরে রাখে (প্রতিটি অন্যটির সাপেক্ষে)। এগুলো একটি নির্দিষ্ট সময়ের মধ্যে গড় এক্সচেঞ্জ রেট গণনা করতে ব্যবহৃত হতে পারে।

1    uint public kLast; // reserve0 * reserve1, সাম্প্রতিকতম লিকুইডিটি ইভেন্টের ঠিক পরের অবস্থা অনুযায়ী
কপি করুন

পেয়ার এক্সচেঞ্জ যেভাবে token0 এবং token1-এর মধ্যে এক্সচেঞ্জ রেট নির্ধারণ করে তা হলো ট্রেডের সময় দুটি রিজার্ভের গুণফল স্থির রাখা। kLast হলো এই মান। এটি পরিবর্তিত হয় যখন কোনো লিকুইডিটি প্রোভাইডার টোকেন জমা দেয় বা তুলে নেয়, এবং 0.3% মার্কেট ফি-এর কারণে এটি সামান্য বৃদ্ধি পায়।

এখানে একটি সহজ উদাহরণ দেওয়া হলো। মনে রাখবেন যে সরলতার স্বার্থে টেবিলে দশমিক বিন্দুর পরে মাত্র তিনটি সংখ্যা রয়েছে, এবং আমরা 0.3% ট্রেডিং ফি উপেক্ষা করেছি তাই সংখ্যাগুলো পুরোপুরি নির্ভুল নয়।

ট্রেডাররা যখন আরও বেশি token0 প্রদান করে, তখন token1-এর আপেক্ষিক মান বৃদ্ধি পায়, এবং এর বিপরীতটিও ঘটে, যা সাপ্লাই এবং ডিমান্ডের ওপর ভিত্তি করে হয়।

লক

1    uint private unlocked = 1;
কপি করুন

নিরাপত্তা দুর্বলতার একটি শ্রেণী রয়েছে যা রিএন্ট্রান্সি অ্যাবিউজ (opens in a new tab)-এর ওপর ভিত্তি করে তৈরি। Uniswap-এর যেকোনো ERC-20 টোকেন ট্রান্সফার করার প্রয়োজন হয়, যার মানে হলো এমন ERC-20 কন্ট্রাক্টগুলোকে কল করা যা তাদের কল করা Uniswap মার্কেটকে অপব্যবহার করার চেষ্টা করতে পারে। কন্ট্রাক্টের অংশ হিসেবে একটি 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)। উভয় ক্ষেত্রেই, জমা দেওয়া বা তুলে নেওয়া token0 এবং token1-এর পরিমাণ ইভেন্টের অংশ, সেইসাথে যে একাউন্ট আমাদের কল করেছে তার পরিচয় (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');
কপি করুন

যদি balance0 বা balance1 (uint256) uint112(-1) (=2^112-1)-এর চেয়ে বেশি হয় (তাই এটি ওভারফ্লো হয় এবং uint112-এ রূপান্তর করার সময় 0-তে ফিরে আসে) তবে ওভারফ্লো রোধ করতে _update চালিয়ে যেতে অস্বীকার করুন। একটি সাধারণ টোকেন যা 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 টাইমস্ট্যাম্পের মধ্যে Token0-এর গড় মূল্য গণনা করতে চাই। 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) এর বৃদ্ধির ১/৬ অংশের সমতুল্য লিকুইডিটি মিন্ট করে
2    function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
কপি করুন

Uniswap 2.0-তে ট্রেডাররা মার্কেট ব্যবহার করার জন্য 0.30% ফি প্রদান করে। সেই ফি-এর বেশিরভাগ অংশ (ট্রেডের 0.25%) সবসময় লিকুইডিটি প্রোভাইডারদের কাছে যায়। বাকি 0.05% লিকুইডিটি প্রোভাইডারদের কাছে অথবা ফ্যাক্টরি দ্বারা প্রটোকল ফি হিসেবে নির্দিষ্ট করা একটি এডড্রেস-এ যেতে পারে, যা Uniswap-কে তাদের ডেভেলপমেন্ট প্রচেষ্টার জন্য অর্থ প্রদান করে।

হিসাব কমানোর জন্য (এবং সেই কারণে গ্যাস খরচ), এই ফি শুধুমাত্র তখনই গণনা করা হয় যখন পুল থেকে লিকুইডিটি যোগ করা বা সরানো হয়, প্রতিটি লেনদেন-এর সময় নয়।

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) {
কপি করুন

যদি নতুন লিকুইডিটি থাকে যার ওপর প্রটোকল ফি সংগ্রহ করতে হবে। আপনি স্কয়ার রুট ফাংশনটি এই আর্টিকেলের পরের অংশে দেখতে পারেন।

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)-এর ৫ পৃষ্ঠায় ব্যাখ্যা করা হয়েছে। আমরা জানি যে 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) ছিল যা কন্ট্রাক্টগুলোকে তাদের অপ্রয়োজনীয় স্টোরেজ শূন্য করে ইথিরিয়াম স্টেট-এর সামগ্রিক আকার কমাতে উৎসাহিত করত। এই কোডটি সম্ভব হলে সেই রিফান্ড পায়।

এক্সটার্নালি অ্যাক্সেসযোগ্য ফাংশন

মনে রাখবেন যে যদিও যেকোনো লেনদেন বা কন্ট্রাক্ট এই ফাংশনগুলোকে কল করতে পারে, এগুলো পেরিফেরি কন্ট্রাক্ট থেকে কল করার জন্য ডিজাইন করা হয়েছে। আপনি যদি এগুলোকে সরাসরি কল করেন তবে আপনি পেয়ার এক্সচেঞ্জকে প্রতারণা করতে পারবেন না, তবে আপনি কোনো ভুলের মাধ্যমে মান হারাতে পারেন।

mint

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। খুব বেশি খরচ নয়।

প্রথম জমার সময় আমরা দুটি টোকেনের আপেক্ষিক মান জানি না, তাই আমরা কেবল পরিমাণগুলো গুণ করি এবং একটি স্কয়ার রুট নিই, এই ধরে নিয়ে যে জমাটি আমাদের উভয় টোকেনে সমান মান প্রদান করে।

আমরা এটিকে বিশ্বাস করতে পারি কারণ আরবিট্রেজ-এ মান হারানো এড়াতে সমান মান প্রদান করা আমানতকারীর স্বার্থে। ধরা যাক দুটি টোকেনের মান অভিন্ন, কিন্তু আমাদের আমানতকারী Token0-এর চেয়ে চারগুণ বেশি Token1 জমা দিয়েছেন। একজন ট্রেডার এই সত্যটি ব্যবহার করতে পারে যে পেয়ার এক্সচেঞ্জ মনে করে Token0 বেশি মূল্যবান, এটি থেকে মান বের করে নিতে।

যেমনটি আপনি দেখতে পাচ্ছেন, ট্রেডার অতিরিক্ত 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) এবং উপযুক্ত ইভেন্ট এমিট করুন।

burn

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; // ব্যালেন্স ব্যবহার করা আনুপাতিক (pro-rata) বন্টন নিশ্চিত করে
4        amount1 = liquidity.mul(balance1) / _totalSupply; // ব্যালেন্স ব্যবহার করা আনুপাতিক (pro-rata) বন্টন নিশ্চিত করে
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 ফাংশনের মিরর ইমেজ।

swap

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} এর জন্য স্কোপ, স্ট্যাক টু ডিপ (stack too deep) এরর এড়ায়
কপি করুন

লোকাল ভেরিয়েবলগুলো মেমরিতে সংরক্ষণ করা যেতে পারে অথবা, যদি সেগুলো খুব বেশি না হয়, তবে সরাসরি স্ট্যাক-এ সংরক্ষণ করা যেতে পারে। যদি আমরা সংখ্যাটি সীমিত করতে পারি যাতে আমরা স্ট্যাক ব্যবহার করব তবে আমরা কম গ্যাস ব্যবহার করি। আরও বিস্তারিত তথ্যের জন্য ইয়েলো পেপার, আনুষ্ঠানিক ইথিরিয়াম স্পেসিফিকেশন (opens in a new tab), পৃষ্ঠা ২৬, সমীকরণ ২৯৮ দেখুন।

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); // অপ্টিমিস্টিক্যালি টোকেন ট্রান্সফার করে
কপি করুন

এই ট্রান্সফারটি অপ্টিমিস্টিক, কারণ সমস্ত শর্ত পূরণ হয়েছে কিনা তা নিশ্চিত হওয়ার আগেই আমরা ট্রান্সফার করি। ইথিরিয়াম-এ এটি ঠিক আছে কারণ যদি কলের পরে শর্তগুলো পূরণ না হয় তবে আমরা এটি থেকে এবং এটি তৈরি করা যেকোনো পরিবর্তন থেকে রিভার্ট করি।

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 এর জন্য স্কোপ, স্ট্যাক টু ডিপ (stack too deep) এরর এড়ায়
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 দিয়ে গুণ করে বিয়োগ করি, এর মানে হলো বর্তমান রিজার্ভের K মানের সাথে এর K মান তুলনা করার আগে ব্যালেন্স থেকে 0.3% (3/1000 = 0.003 = 0.3%) কেটে নেওয়া হচ্ছে।

1        }
2
3        _update(balance0, balance1, _reserve0, _reserve1);
4        emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
5    }
কপি করুন

reserve0 এবং reserve1 আপডেট করুন, এবং প্রয়োজন হলে প্রাইস অ্যাকুমুলেটর এবং টাইমস্ট্যাম্প আপডেট করুন এবং একটি ইভেন্ট এমিট করুন।

Sync বা Skim

আসল ব্যালেন্সগুলোর পক্ষে পেয়ার এক্সচেঞ্জ-এর মনে করা রিজার্ভের সাথে সিঙ্ক না হওয়া সম্ভব। কন্ট্রাক্টের সম্মতি ছাড়া টোকেন তুলে নেওয়ার কোনো উপায় নেই, তবে জমা দেওয়া একটি ভিন্ন বিষয়। একটি একাউন্ট 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), পৃষ্ঠা ৫ দেখুন)। feeTo এডড্রেস প্রটোকল ফি-এর জন্য লিকুইডিটি টোকেনগুলো জমা করে, এবং feeToSetter হলো সেই এডড্রেস যাকে feeTo-কে একটি ভিন্ন এডড্রেস-এ পরিবর্তন করার অনুমতি দেওয়া হয়েছে।

1    mapping(address => mapping(address => address)) public getPair;
2    address[] public allPairs;
কপি করুন

এই ভেরিয়েবলগুলো পেয়ারগুলোর, দুটি টোকেন টাইপের মধ্যে এক্সচেঞ্জগুলোর ট্র্যাক রাখে।

প্রথমটি, getPair, হলো একটি ম্যাপিং যা একটি পেয়ার এক্সচেঞ্জ কন্ট্রাক্টকে এটি যে দুটি ERC-20 টোকেন এক্সচেঞ্জ করে তার ওপর ভিত্তি করে শনাক্ত করে। ERC-20 টোকেনগুলো সেই কন্ট্রাক্টগুলোর এডড্রেস দ্বারা শনাক্ত করা হয় যা সেগুলোকে বাস্তবায়ন করে, তাই কী (keys) এবং মান (value) সবই হলো এডড্রেস। পেয়ার এক্সচেঞ্জের এডড্রেস পেতে যা আপনাকে tokenA থেকে tokenB-তে রূপান্তর করতে দেয়, আপনি getPair[<tokenA address>][<tokenB address>] ব্যবহার করেন (অথবা এর উল্টোটা)।

দ্বিতীয় ভেরিয়েবল, allPairs, হলো একটি অ্যারে যা এই ফ্যাক্টরি দ্বারা তৈরি সমস্ত পেয়ার এক্সচেঞ্জের এডড্রেস অন্তর্ভুক্ত করে। ইথিরিয়াম-এ আপনি একটি ম্যাপিংয়ের কন্টেন্টের ওপর ইটারেট করতে পারবেন না, বা সমস্ত কী-এর একটি তালিকা পেতে পারবেন না, তাই এই ফ্যাক্টরি কোন এক্সচেঞ্জগুলো পরিচালনা করে তা জানার একমাত্র উপায় হলো এই ভেরিয়েবলটি।

দ্রষ্টব্য: আপনি একটি ম্যাপিংয়ের সমস্ত কী-এর ওপর ইটারেট করতে না পারার কারণ হলো কন্ট্রাক্ট ডাটা স্টোরেজ ব্যয়বহুল, তাই আমরা এটি যত কম ব্যবহার করি ততই ভালো, এবং আমরা এটি যত কম পরিবর্তন করি ততই ভালো। আপনি ইটারেশন সমর্থন করে এমন ম্যাপিং (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 টোকেনের মধ্যে একটি পেয়ার এক্সচেঞ্জ তৈরি করা। মনে রাখবেন যে যেকেউ এই ফাংশনটি কল করতে পারে। একটি নতুন পেয়ার এক্সচেঞ্জ তৈরি করতে আপনার Uniswap থেকে অনুমতির প্রয়োজন নেই।

1        require(tokenA != tokenB, 'UniswapV2: IDENTICAL_ADDRESSES');
2        (address token0, address token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
কপি করুন

আমরা চাই নতুন এক্সচেঞ্জের এডড্রেসটি ডিটারমিনিস্টিক হোক, যাতে এটি আগে থেকেই অফচেইন গণনা করা যায় (এটি লেয়ার ২ লেনদেন-এর জন্য দরকারী হতে পারে)। এটি করার জন্য আমাদের টোকেন এডড্রেসগুলোর একটি সামঞ্জস্যপূর্ণ ক্রম থাকতে হবে, আমরা যে ক্রমেই সেগুলো পেয়ে থাকি না কেন, তাই আমরা সেগুলোকে এখানে সাজাই।

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);
5    }
কপি করুন

স্টেট ভেরিয়েবলগুলোতে নতুন পেয়ারের তথ্য সংরক্ষণ করুন এবং বিশ্বকে নতুন পেয়ার এক্সচেঞ্জ সম্পর্কে জানাতে একটি ইভেন্ট এমিট করুন।

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 লিকুইডিটি টোকেন বাস্তবায়ন করে। এটি OpenZeppelin ERC-20 কন্ট্রাক্ট-এর মতোই, তাই আমি শুধুমাত্র সেই অংশটি ব্যাখ্যা করব যা ভিন্ন, permit কার্যকারিতা।

ইথিরিয়াম-এ লেনদেন-এর জন্য ইথার (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) পুনরুদ্ধার করার কোড। এটি Yul (opens in a new tab) নামক একটি EVM অ্যাসেম্বলি ডায়ালেক্ট ব্যবহার করে। মনে রাখবেন যে Yul-এর বর্তমান সংস্করণে আপনাকে 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(...) হলো সেই মেসেজ যা আমরা পাওয়ার আশা করি। আমরা জানি নন্স কী হওয়া উচিত, তাই আমাদের এটি প্যারামিটার হিসেবে পাওয়ার কোনো প্রয়োজন নেই।

ইথিরিয়াম সিগনেচার এ্যালগরিদম সাইন করার জন্য 256 বিট পাওয়ার আশা করে, তাই আমরা keccak256 হ্যাস ফাংশন ব্যবহার করি।

1        address recoveredAddress = ecrecover(digest, v, r, s);
কপি করুন

ডাইজেস্ট এবং সিগনেচার থেকে আমরা ecrecover (opens 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) হিসেবে বিবেচনা করুন।

পেরিফেরি কন্ট্রাক্টস

পেরিফেরি কন্ট্রাক্টগুলো হলো Uniswap-এর API (এপ্লিকেশন প্রোগ্রাম ইন্টারফেস)। এগুলো অন্যান্য কন্ট্রাক্ট বা ডিসেন্ট্রালাইজড এপ্লিকেশন থেকে এক্সটার্নাল কলের জন্য এভেইলেবল। আপনি চাইলে সরাসরি কোর কন্ট্রাক্টগুলোকে কল করতে পারেন, তবে এটি বেশ জটিল এবং ভুল করলে আপনার ভ্যালু বা ফান্ড হারাতে পারেন। কোর কন্ট্রাক্টগুলোতে শুধুমাত্র এমন টেস্ট থাকে যা নিশ্চিত করে যে তাদের সাথে কোনো প্রতারণা করা হচ্ছে না, অন্য কারো জন্য কোনো স্যানিটি চেক এতে থাকে না। সেগুলো পেরিফেরিতে থাকে যাতে প্রয়োজন অনুযায়ী আপডেট করা যায়।

UniswapV2Router01.sol

এই কন্ট্রাক্টে (opens in a new tab) কিছু সমস্যা রয়েছে এবং এটি আর ব্যবহার করা উচিত নয় (opens in a new tab)। সৌভাগ্যবশত, পেরিফেরি কন্ট্রাক্টগুলো স্টেটলেস এবং এগুলো কোনো অ্যাসেট ধরে রাখে না, তাই এটিকে সহজেই বাতিল করা যায় এবং এর পরিবর্তে মানুষকে UniswapV2Router02 ব্যবহার করার পরামর্শ দেওয়া যায়।

UniswapV2Router02.sol

বেশিরভাগ ক্ষেত্রেই আপনি এই কন্ট্রাক্টের (opens in a new tab) মাধ্যমে Uniswap ব্যবহার করবেন। এটি কীভাবে ব্যবহার করতে হয় তা আপনি এখানে (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। Uniswap v2 যেকোনো জোড়া ERC-20 টোকেনের জন্য এক্সচেঞ্জ করার অনুমতি দেয়, কিন্তু ইথার (ETH) নিজে কোনো ERC-20 টোকেন নয়। এটি স্ট্যান্ডার্ডের আগের এবং ইউনিক মেকানিজমের মাধ্যমে ট্রান্সফার করা হয়। ERC-20 টোকেনের ক্ষেত্রে প্রযোজ্য কন্ট্রাক্টগুলোতে ETH-এর ব্যবহার সক্ষম করতে মানুষ wrapped ether (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) উল্লেখ করুন।

লিকুইডিটি প্রোভাইডাররা সাধারণত একটি সর্বনিম্ন পরিমাণ নির্দিষ্ট করে দেন, কারণ তারা লেনদেনটিকে বর্তমান এক্সচেঞ্জ রেটের কাছাকাছি সীমাবদ্ধ রাখতে চান। যদি এক্সচেঞ্জ রেট খুব বেশি ওঠানামা করে, তবে এর মানে হতে পারে এমন কোনো খবর যা আন্ডারলাইং ভ্যালু পরিবর্তন করে দিয়েছে, এবং তারা ম্যানুয়ালি সিদ্ধান্ত নিতে চান যে কী করতে হবে।

উদাহরণস্বরূপ, এমন একটি পরিস্থিতি কল্পনা করুন যেখানে এক্সচেঞ্জ রেট এক-এর বিপরীতে এক (1:1) এবং লিকুইডিটি প্রোভাইডার এই ভ্যালুগুলো নির্দিষ্ট করেছেন:

যতক্ষণ এক্সচেঞ্জ রেট 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::mint (opens 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);
2    }
কপি করুন

এর বিনিময়ে পুলের আংশিক মালিকানার জন্য to এডড্রেসকে লিকুইডিটি টোকেন দিন। কোর কন্ট্রাক্টের mint ফাংশন দেখে যে এর কাছে কতগুলো অতিরিক্ত টোকেন আছে (শেষবার লিকুইডিটি পরিবর্তন হওয়ার সময়ের তুলনায়) এবং সেই অনুযায়ী লিকুইডিটি মিন্ট করে।

1    function addLiquidityETH(
2        address token,
3        uint amountTokenDesired,
কপি করুন

যখন একজন লিকুইডিটি প্রোভাইডার একটি Token/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        // ডাস্ট (dust) eth থাকলে তা রিফান্ড করুন
3        if (msg.value > amountETH) TransferHelper.safeTransferETH(msg.sender, msg.value - amountETH);
4    }
কপি করুন

ব্যবহারকারী ইতিমধ্যেই আমাদের 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    }
সব দেখানকপি করুন

চূড়ান্ত ফাংশনটি মেটা-ট্রানজেকশনের সাথে স্টোরেজ ফি যুক্ত করে।

ট্রেড

1    // **** সোয়াপ ****
2    // প্রাথমিক পরিমাণটি ইতিমধ্যে প্রথম পেয়ারে পাঠানো হয়েছে তা প্রয়োজন
3    function _swap(uint[] memory amounts, address[] memory path, address _to) internal virtual {
কপি করুন

এই ফাংশনটি ইন্টারনাল প্রসেসিং সম্পন্ন করে যা ট্রেডারদের জন্য উন্মুক্ত ফাংশনগুলোর জন্য প্রয়োজনীয়।

1        for (uint i; i < path.length - 1; i++) {
কপি করুন