什么是去中央化交易所聚合器?_数字货币

[2021-02-09 17:59:32] 来源：编辑：wangjia 点击量：

评论 点击收藏

导读： 什么是Manta Network？MantaNetwork正在建立一个可互操作的，保护隐私的去中心化交易所从代码角度上看懂DEX的聚合买卖？ 1inch发币了，不知道列位老铁有没有领到。有的人黑

什么是Manta Network？

MantaNetwork正在建立一个可互操作的，保护隐私的去中心化交易所

从代码角度上看懂DEX的聚合买卖？

1inch发币了，不知道列位老铁有没有领到。有的人黑暗窃喜，有人还不领会 1inch，这篇文件就先容了 1inch 的焦点功效。

文章的主要步骤如下：

获得最大的收益兑换方案

授权1inch合约操作你的代币

行使第一步获得的兑换方案举行买卖

什么是去中央化买卖所聚合器?

去中央化买卖所聚合器，即 DEX，以下都用 DEX 示意。DEX 聚合器是一个平台，它将搜索一组 DEX，以寻找在给定时间和数目下执行买卖的最佳价钱。

1inch DEX 聚合器

1inch 的一大特色就是聚合买卖，它会在许多个 DEX 找到收益最大的成交方式。好比 100000dai 想买 x 个 eth，在 uniswap 成交 77%，在 Bancor 成交 23% ，是最合算的，买到的 eth 最多。

1inch 是由 Anton Bukov 和 Sergej Kunz 开发的 DEX 聚合器，通过一次买卖将订单在多个 DEX 之间拆分，给用户提供最好的兑换汇率。1inch 的智能合约是开源的。

在 1inch 执行买卖，历程实在很简朴：

凭据输入的 token 或 ETH 数目，获得预期可兑换的 token 数目

授权（Approve）买卖所使用你的 token

使用第一步的获取的 token 数目举行买卖

我们首先仔细领会一下 1inch 的智能合约，让我们感兴趣的是这两个方式：

getExpectedReturn()

swap()

getExpectedReturn - 估算最佳兑换方案

getExpectedReturn 可以随意挪用，不需要消耗任何 gas。

这个函数需要传入兑换参数，返回兑换的期望效果，以及买卖在各个 dex 之间的兑换比例。

function getExpectedReturn(
 IERC20 fromToken,
 IERC20 toToken,
 uint256 amount,
 uint256 parts,
 uint256 disableFlags
) public view
returns(
 uint256 returnAmount,
 uint256[] memory distribution
);

这个方式吸收 5 个参数：

fromToken：当前拥有的 token 的地址

toToken：要交流的 token 的地址

amount：想要交流的 token 数目

parts：卖出数目拆分成若干份举行最优漫衍的估算。查看distribution 可以领会更多细节，默认是 100

disableFlags：符号位，用于调整 1inch 的算法，例如可设置禁用某个特定的 DEX

这个方式有 2 个返回值：

returnAmount：执行买卖后将收到的 token 数目。

distribution：一个 uint256 类型的数组，代表买卖在差别 DEX 中的漫衍情形。例如，parts 设置为 100，成交额度的 25％在 Kyber 的，成交额度的 75％在 Uniswap，那么 distribution 看起来是这样的：[75, 25, 0, 0, …]。

现在 1inch 支持的买卖所和排序（与 distribution 对应）如下：

[
 "Uniswap", "Kyber", "Bancor", "Oasis",
 "CurveCompound", "CurveUsdt", "CurveY",
 "Binance", "Synthetix",
 "UniswapCompound", "UniswapChai", "UniswapAave"
]

注重：若是你想买卖 Eth 而不是 ERC20 token，fromToken 需要设置为特殊的值 0x0或 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE。

getExpectedReturn函数的返回值异常重要，由于接下来需要行使它来执行现实的链上兑换操作。

swap - 执行多 DEX 兑换买卖

要执行链上 token 兑换买卖，就需要使用合约提供的另一个函数swap。挪用swap时，需要传入我们之前从getExpectedReturn返回的数据，这个操作需要破费 gas。若是要卖出的是 ERC20 token，那么还需要先授权 1inch 合约可以操作你持有的待卖出 token。swap函数的界说如下：

function swap(
 IERC20 fromToken,
 IERC20 toToken,
 uint256 amount,
 uint256 minReturn,
 uint256[] memory distribution,
 uint256 disableFlags
 ) public payable;

swap 函数吸收 6 个参数：

fromToken：待卖出 token 的地址

toToken：待买入 token 的地址

amount：待卖出 token 的数目

minReturn：期望获得的待买入 token 的最少数目

distribution：兑换买卖拆分漫衍数组

parts：执行估算时的拆分数目，默认值是 100

disableFlags：符号位，例如可设置禁用某个特定的 DEX

开发环境搭建

我们将使用 ganache-cli 分叉(fork)当前的区块链状态[4]，并提前在 1 个地址上充值了许多 DAI。在示例中，地址是 0x78bc49be7bae5e0eec08780c86f0e8278b8b035b。我们还将 gas limit 设置的异常高，因此在测试历程中不至于泛起 out of gas 的问题，也不需要在每次买卖前估算 gas。启动下令是：

ganache-cli -f https://mainnet.infura.io/v3/[YOUR INFURA KEY] 
-d -i 66 
--unlock 0x78bc49be7bae5e0eec08780c86f0e8278b8b035b 
-l 8000000

实战 - 估算最佳兑换方案

剖析完了 1inch 的要害方式，我们将举行第一笔兑换买卖，代码已在 github 开源：https://github.com/liushooter/ethereumdevio-dex-tutorial/blob/master/part1/index.js。

var Web3 = require('web3');
const BigNumber = require('bignumber.js');
const oneSplitABI = require('./abis/onesplit.json');
const onesplitAddress = "0xC586BeF4a0992C495Cf22e1aeEE4E446CECDee0E"; // 1plit contract address on Main net
const fromToken = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'; // ETHEREUM
const fromTokenDecimals = 18;
const toToken = '0x6b175474e89094c44da98b954eedeac495271d0f'; // DAI Token
const toTokenDecimals = 18;
const amountToExchange = 1
const web3 = new Web3('http://127.0.0.1:8545');
const onesplitContract = new web3.eth.Contract(oneSplitABI, onesplitAddress); // （1）
const oneSplitDexes = ["Uniswap", "Kyber", "Bancor", // （2）
 "Oasis", "CurveCompound", "CurveUsdt", "CurveY", "Binance", "Synthetix", "UniswapCompound", "UniswapChai", "UniswapAave"
onesplitContract.methods.getExpectedReturn(fromToken, toToken, // （3）
 new BigNumber(amountToExchange).shiftedBy(fromTokenDecimals).toString(), 100, 0).call({
 from: '0x9759A6Ac90977b93B58547b4A71c78317f391A28'
}, function(error, result) {
 if (error) {
 console.log(error)
 return;
 }
 console.log("Trade From: " + fromToken)
 console.log("Trade To: " + toToken);
 console.log("Trade Amount: " + amountToExchange);
 console.log(new BigNumber(result.returnAmount).shiftedBy(-fromTokenDecimals).toString());
 console.log("Using Dexes:");
 for (let index = 0; index  result.distribution.length; index++) { console.log(oneSplitDexes[index] + ": " + result.distribution[index] + "%"); } });

（1）加载 ABI 以便实例化 1inch 合约实例

（2）该数组指定要使用的 DEX

（3）挪用getExpectedReturn函数获取兑换方案

代码执行后返回效果类似下面这样：

此时卖出 1 个 eth，1inch 可以买到 148.47DAI，而 Coinbase 是 148.12。1inch 给出的最佳兑换方案是通过 Uniswap 兑换 96%，再通过 Bancor 兑换 4%，这样可以获得 148.47 DAI，这样比单独通过 Uniswap 或 Bancor 举行兑换都划算。

注重，这个价钱不能作为智能合约的 Oracle 价钱，由于林林总总的错误，DEX 可以提供异常低的价钱，因此可能会严重操作这个价钱。

实战 - 执行多 DEX 兑换方案

下面我们使用 1inch 聚合器将 1000 DAI 兑换为 ETH。首先界说一些变量，例如合约地址、ABI 等。

var Web3 = require('web3');
const BigNumber = require('bignumber.js');
const oneSplitABI = require('./abis/onesplit.json');
const onesplitAddress = "0xC586BeF4a0992C495Cf22e1aeEE4E446CECDee0E"; // 1plit contract address on Main net
const erc20ABI = require('./abis/erc20.json');
const daiAddress = "0x6b175474e89094c44da98b954eedeac495271d0f"; // DAI ERC20 contract address on Main net
const fromAddress = "0x4d10ae710Bd8D1C31bd7465c8CBC3add6F279E81";
const fromToken = daiAddress;
const fromTokenDecimals = 18;
const toToken = '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE'; // ETH
const toTokenDecimals = 18;
const amountToExchange = new BigNumber(1000);
const web3 = new Web3(new Web3.providers.HttpProvider('http://127.0.0.1:8545'));
const onesplitContract = new web3.eth.Contract(oneSplitABI, onesplitAddress);
const daiToken = new web3.eth.Contract(erc20ABI, fromToken);

同时写一个辅助函数来守候买卖确认：

function sleep(ms) {
 return new Promise(resolve =  setTimeout(resolve, ms));
async function waitTransaction(txHash) {
 let tx = null;
 while (tx == null) {
 tx = await web3.eth.getTransactionReceipt(txHash);
 await sleep(2000);
 }
 console.log("Transaction " + txHash + " was mined.");
 return (tx.status);
}

我们在之前已经获得了兑换比率，现在把代码变的更可读，界说 1 个getQuote函数，返回一个包罗所有参数的工具。

async function getQuote(fromToken, toToken, amount, callback) {
 let quote = null;
 try {
 quote = await onesplitContract.methods.getExpectedReturn(fromToken, toToken, amount, 100, 0).call();
 } catch (error) {
 console.log('Impossible to get the quote', error)
 }
 console.log("Trade From: " + fromToken)
 console.log("Trade To: " + toToken);
 console.log("Trade Amount: " + amountToExchange);
 console.log(new BigNumber(quote.returnAmount).shiftedBy(-fromTokenDecimals).toString());
 console.log("Using Dexes:");
 for (let index = 0; index  quote.distribution.length; index++) { console.log(oneSplitDexes[index] + ": " + quote.distribution[index] + "%"); } callback(quote); }

一旦我们获得了兑换 token 的比率，接下来需要授权 1inch 可以操作我们持有的 token，ERC20 token 尺度不允许在一次买卖中向合约发送 token 并触发下一个操作。我们写了一个简朴的函数，挪用approval函数，并使用 waitTransaction 守候买卖确认。

function approveToken(tokenInstance, receiver, amount, callback) {
 tokenInstance.methods.approve(receiver, amount).send({ from: fromAddress }, async function(error, txHash) {
 if (error) {
 console.log("ERC20 could not be approved", error);
 return;
 }
 console.log("ERC20 token approved to " + receiver);
 const status = await waitTransaction(txHash);
 if (!status) {
 console.log("Approval transaction failed.");
 return;
 }
 callback();
 })
}

注重，这里演示的时刻授权额度远远高于当前现实需要的数目，这样后续就不需要频频执行这个操作了。

接下来就可以挪用 1inch 聚合器的 swap 函数了。在下面的代码中，我们在挪用swap函数执行买卖后，守候买卖确认，并在买卖确认后，显示转出账户的 eth 余额和 dai 余额。

let amountWithDecimals = new BigNumber(amountToExchange).shiftedBy(fromTokenDecimals).toFixed()
getQuote(fromToken, toToken, amountWithDecimals, function(quote) {
 approveToken(daiToken, onesplitAddress, amountWithDecimals, async function() {
 // We get the balance before the swap just for logging purpose
 let ethBalanceBefore = await web3.eth.getBalance(fromAddress);
 let daiBalanceBefore = await daiToken.methods.balanceOf(fromAddress).call();
 onesplitContract.methods.swap(fromToken, toToken, amountWithDecimals, quote.returnAmount, quote.distribution, 0).send({ from: fromAddress, gas: 8000000 }, async function(error, txHash) {
 if (error) {
 console.log("Could not complete the swap", error);
 return;
 }
 const status = await waitTransaction(txHash);
 // We check the final balances after the swap for logging purpose
 let ethBalanceAfter = await web3.eth.getBalance(fromAddress);
 let daiBalanceAfter = await daiToken.methods.balanceOf(fromAddress).call();
 console.log("Final balances:")
 console.log("Change in ETH balance", new BigNumber(ethBalanceAfter).minus(ethBalanceBefore).shiftedBy(-fromTokenDecimals).toFixed(2));
 console.log("Change in DAI balance", new BigNumber(daiBalanceAfter).minus(daiBalanceBefore).shiftedBy(-fromTokenDecimals).toFixed(2));
 });
 });
});

最后的执行效果看起来是下面这样的：

我们用 1000 DAI 换回来 5.85 ETH。

在这个历程中，你可能会遇到的这样一个错误提醒：“VM Exception while processing transaction: revert OneSplit: actual return amount is less than minReturn”。这示意链上的报价已经更新。若是想制止这种情形发生，你可以在代码中引入一个滑点，凭据买卖金额，将 minReturn 参数减小 1%或 3%。

1inch 提供了精彩的链上 DEX 聚合实现，可以在一个买卖内行使多个 DEX 实现最优的兑换计谋。1inch 的 API 使用也很简朴，只需要用 getExpectedReturn 估算兑换方案，然后使用 swap 执行兑换方案，就可以获得最好的兑换效果。你不必总是用 eth 买卖，也可以交流 2 个 ERC20 token，甚至可以用 weth 买卖。