在不使用uniswap的情况下使用坚固性创建令牌的交换函数（与速率交换）

Question

我是该领域的新手，只是在网上学习一些有关坚固性并创建简单合同的课程，我想询问我尝试但尚未成功的简单项目。 我想创建一个可以交换函数，该函数可以在我从ERC20创建的2个令牌之间进行交换，而无需使用uniswap或类似的内容，只需开发一个新函数，可以在令牌a和令牌B之间交换，例如1令牌A的速率A = 3令牌B，要求速率保存在映射中并首先获得配置，但是我真的不知道如何设置交换速率。 任何人都可以帮助我，谢谢大家。

存在掉期合同的代码，只是临时：

// SPDX-License-Identifier: MIT
pragma solidity >= 0.7.0 <0.9.0;

import "./Token.sol";
import "./safemath.sol";

contract SwapToken {
    using SafeMath for uint;

    Token public token1;
    address public owner1;
    Token public token2;
    address public owner2;
    uint public amount1;
    uint public amount2;
    uint public swapRate;

    constructor(
        address _token1,
        address _owner1,
        address _token2,
        address _owner2,
        uint _amount1
    ) {
        token1 = Token(_token1);
        owner1 = _owner1;
        token2 = Token(_token2);
        owner2 = _owner2;
        swapRate = 3;
        amount1 = _amount1;
        amount2 = _amount1.mul(swapRate);
    }

    function swap() public {
        require(msg.sender == owner1 || msg.sender == owner2, "Not authorized from owners");
        require(
            token1.allowance(owner1, address(this)) >= amount1,
            "Token 1 allowance too low"
        );
        require(
            token2.allowance(owner2, address(this)) >= amount2,
            "Token 2 allowance too low"
        );

        _safeTransferFrom(token1, owner1, owner2, amount1);
        _safeTransferFrom(token2, owner2, owner1, amount2);
    }

    function _safeTransferFrom(
        Token token,
        address sender,
        address recipient,
        uint amount
    ) private {
        bool sent = token.transferFrom(sender, recipient, amount);
        require(sent, "Token transfer failed");
    }
}

Answer 1

让我们从一个一般的答案开始，我们将基于它，因为我们更好地了解这个问题。

我认为您不是要使用流动性池创建交换解决方案，而是想匹配想要交换代币的2个人（？）。

然后，可以在交换时，可以进行简单的方法

// have a mapping, as your tutor said. This will store information about how a token (token's contract address) and another token (again, contract address) rate against each other.
mapping(address => mapping (address => uint256)) rates;

function setRating(address memory token1, address memory token2, uint256 rate) public {
     rates[token1][token2] = rate;
}

，然后检查速率并相应地计算。

Answer 2

// you need to pass which token to swap and how much swap
function swap(address tokenIn, uint amountIn) public {
    // you want only either of two owners call
    require(
        msg.sender == owner1 || msg.sender == owner2,
        "Not authorized from owners"
    );
    require(
        token1.allowance(owner1, address(this)) >= amount1,
        "Token 1 allowance too low"
    );
    require(
        token2.allowance(owner2, address(this)) >= amount2,
        "Token 2 allowance too low"
    );
    // you need to require tokenIn is only token1 or token2 that you store in storage
    require(
        tokenIn == address(token1) || tokenIn == address(token2),
        "Invalid token"
    );
    // make sure you pass positive amount
    require(_amountIn > 0, "invalid amount");
    // define token1 and token2 based on function arg tokenIn
    bool isToken1 = tokenIn == address(token1);
    (   // you are using Token as type instead of IERC20
        Token tokenIn,
        Token tokenOut,
        // reserve1 and reserve2 how many each tokens holds. you should be setting in state
        uint reserve1,
        uint reserve2
    ) = isToken1
            ? (token1, token2, reserve1, reserve2)
            : (token2, token1, reserve2, reserve1);
    // instead token1, tokenIn should be transferred
    // I believe this is what it does
    _safeTransferFrom(tokenIn, owner1, owner2, amount1);
    // calculate the tokenOut including the fee=0.3%. user who wants to swap has to pay for fee
    uint amountInAfterFee = (_amountIn * 997) / 1000;
    // here you need to calculate how much y token will be taken out
    // this is the formula dy=(y*dx)/(x+dx) y and x are reserves, dx is amountInAfterFee
     amountOut =
        (reserve2 * amountInAfterFee) /
        (reserve1 + amountInAfterFee);
    // now you need to send this amountOut to tokenOut or token2 in your contract
    token2.transfer(msg.sender,amountOut)
    // here update the reserves

    // I dont think that you need this
    // _safeTransferFrom(token2, owner2, owner1, amount2);
}