hastebin-1740417910194

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
interface IERC20 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function setPrice (uint256 newPrice) external;
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function allowance (address owner, address spender) external view returns (uint256);
    function approve (address spender, uint256 amount) external view returns (bool);
    function transfer (address recipient, uint256 amount) external view returns (bool);
    function transferFrom (address sender, address recipient, uint256 amount) external view returns (bool);
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed owner, address indexed spender, uint256 value); 

}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
import "./IERC20.sol;";

contract ERC20 is IERC20 {
    string private _name;
    string private _symbol;
    uint8 private _decimals = 18;
    uint256 private _totalSupply;
    uint256 private price;
    address private owner;
    mapping(address=>uint256) private _balances;
    mapping(address=>mapping(address=>uint256)) private _allowances;
    uint256 private price; 

    constructor(string memory name_, string memory symbol_, uint256 initialSupply, uint initialPrice){
        _name = name;
        _symbol=symbol_;
        _totalSupply=initialSupply;
        owner=msg.sender;
        _mint(msg.sender, inlitialSupply);
        _balances[msg.sender]=_totalSupply;
        price=initialPrice;
    } 
    modifier onlyOwner() virtual {
        require(msg.sender=owner, "not owner");
        _;
    }
    function SetPrice(uint256 newPrice) external override onlyOwner{
        price=newPrice;
    }
    function name () public view override returns (string memory){
        return _name;
    }
    function symbol() public view override returns (string memory){
        return _simbol;
    }
    function decimals() public view override returns (uint256){
        return _decimals;
    }
    function totalSupply() public view override returns (uint256){
        return _totalSupply;
    }
    function balanceOf(address account) public override view returns (uint256){
        return _balances[account];
    }
    function transfer(address recipient, uint256 amount) public view override returns (bool success){
        require(_balances[msg.sender]>=amount, "balances lowered");
        require(recipient!=address(0), "invalid recipient address");
        _balances[msg.sender]-=amount;
        _balances[recipient]+=amount;
        emit Transfer (msg.sender, recipient, amount);
        return true;
    }
    function allowance (address owner, address spender) external view returns (uint256){
        return _allowances[TokenOwner][spender];
    }
    function approve (address spender, uint256 amount) external view returns (bool){
        require(spender !=address(0), "invalid spender address");
        _allowances[owner][spender]=amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }
    function transferFrom(address sender, address recipient, uint256 amount) external view returns (bool){
        require(recipient != address(0), "invalid address");
        require(sender != address(0), "invalid address");
        require(_balances[msg.sender]>=amount);
        require(_allowances[sender][msg.sender]>=amount, "transfer amount exceeds balance");
        _balances[sender]-=amount;
        _balances[recipient]+=amount;
        _allowances[sender][msg.sender]-=amount;
        emit Transfer(msg.sender, recipient, amount);
        return true;
    }
    function _mint(address account, uint256 amount) internal {
        require(account != address(0), "invalid address");
        _totalSupply += amount * (10 ** uint256(_decimals));
        _balances[account] += amount * (10 ** uint256(_decimals));
        emit Transfer(address(0), account, amount * 10 ** uint256(_decimals));
    }
    function burn(uint256 amount) public virtual {
        require(msg.sender==owner, "not owner");
        require(_balances[msg.sender]>=amount, "balance lowered");
        _burn(msg.sender, amount);
        
    } 
    function _burn(address account, amount) internal {
        require(account != address(0), "invalid address");
        _totalSupply -= amount * (10**uint256(_decimals));
        _balances[account]-= amount * (10**uint256(_decimals));
        emit Transfer(address(0), account, amount * 10 ** uint256(_decimals));
    }
}




// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC20.sol";

contract GerdaCoin is ERC20 {
    address private owner;

constructor() ERC20("GerdsCoin", "GDX", 1000000*10**18, 1 ether){
    owner = msg.sender;
    }
    modifier onlyOwner(){
        require(msg.sender==owner, "not owner");
    }
    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }
    function setPrice() external view returns (uint256) {
        return 3 ether / 10**decimals();
    }
}





// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./IERC20.sol";
import "./LP.sol"; 

contract LiquidityPool {
    IERC20 public tokenA;
    IERC20 public tokenB;
    LP public lpToken; 

    uint256 public reserveA;
    uint256 public reserveB;

    uint256 public totalLiquidity; 

    constructor(address _tokenA, address _tokenB, address _lpToken) {
        tokenA = IERC20(_tokenA);
        tokenB = IERC20(_tokenB);
        lpToken = LP(_lpToken); 
    }

    function addLiquidity(uint256 amountA, uint256 amountB) external {
        require(amountA > 0 && amountB > 0, "Invalid amounts"); 
        tokenA.transferFrom(msg.sender, address(this), amountA);
        tokenB.transferFrom(msg.sender, address(this), amountB);

        uint256 liquidity;
        if (totalLiquidity == 0) {
            liquidity = amountA + amountB; 
        } else {
            liquidity = min((amountA * totalLiquidity) / reserveA, (amountB * totalLiquidity) / reserveB);
        }

        reserveA += amountA;
        reserveB += amountB;
        totalLiquidity += liquidity;

        lpToken.mint(msg.sender, liquidity);
    }

    function swap(address tokenFrom, address tokenTo, uint256 amountIn) external {
        require(tokenFrom != address(0), "Invalid from address");
        require(tokenTo != address(0), "Invalid to address");
        require(amountIn > 0, "Invalid amount");

        bool isA = tokenFrom == address(tokenA);
        require(isA || tokenFrom == address(tokenB), "Invalid token");

        IERC20 tokenIn = isA ? tokenA : tokenB;
        IERC20 tokenOut = isA ? tokenB : tokenA;
        uint256 reserveIn = isA ? reserveA : reserveB;
        uint256 reserveOut = isA ? reserveB : reserveA;

        // Расчет количества выходного токена (с учетом автоматического баланса)
        uint256 amountOut = (amountIn * reserveOut) / (reserveIn + amountIn);
        require(amountOut > 0, "Insufficient output amount"); // Проверка на достаточное количество выходного токена

        // Совершаем обмен
        tokenIn.transferFrom(msg.sender, address(this), amountIn);
        tokenOut.transfer(msg.sender, amountOut);

        // Обновляем резервы
        if (isA) {
            reserveA += amountIn;
            reserveB -= amountOut;
        } else {
            reserveB += amountIn;
            reserveA -= amountOut;
        }
    }

    // Функция для нахождения минимума
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }
}







// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./LiquidityPool.sol";

contract PoolFactory {
    mapping(address => mapping(address => address)) public getPool; // Хранит адреса пулов
    address[] public allPools; // Массив всех пулов

    event PoolCreated(address indexed tokenA, address indexed tokenB, address pool);

    function createPool(address tokenA, address tokenB, address lpToken) external returns (address pool) {
        require(tokenA != tokenB, "Identical token addresses");
        require(tokenA != address(0) && tokenB != address(0), "Zero address");
        require(getPool[tokenA][tokenB] == address(0), "Pool already exists");

        // Создаем новый пул
        LiquidityPool newPool = new LiquidityPool(tokenA, tokenB, lpToken);
        pool = address(newPool); // Исправлено: убрано повторное объявление переменной

        // Записываем в mapping (в обе стороны)
        getPool[tokenA][tokenB] = pool;
        getPool[tokenB][tokenA] = pool;
        allPools.push(pool);

        emit PoolCreated(tokenA, tokenB, pool);
    }

    function getAllPools() external view returns (address[] memory) {
        return allPools;
    }
}









// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./PoolFactory.sol";
import "./LiquidityPool.sol";
import "./IERC20.sol";

contract Router {
    PoolFactory public factory;

    event SwapCompleted(address indexed user, address indexed tokenIn, address indexed tokenOut, uint256 amountIn, uint256 amountOut);

    constructor(address _factory) {
        factory = PoolFactory(_factory);
    }

    // Функция для обмена через один пул
    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 minAmountOut,
        address[] memory path
    ) external {
        require(path.length >= 2, "Invalid path length");

        address tokenIn = path[0];
        address tokenOut = path[path.length - 1];

        IERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn);

        uint256 amountOut = _swap(amountIn, path);

        require(amountOut >= minAmountOut, "Slippage exceeded");

        IERC20(tokenOut).transfer(msg.sender, amountOut);

        emit SwapCompleted(msg.sender, tokenIn, tokenOut, amountIn, amountOut);
    }

// Внутренняя функция, которая выполняет обмен через один или несколько пулов
    function _swap(uint256 amountIn, address[] memory path) internal returns (uint256) {
        uint256 amountOut = amountIn;
        for (uint256 i = 0; i < path.length - 1; i++) {
        address tokenA = path[i];
        address tokenB = path[i + 1];
        address poolAddress = factory.getPool(tokenA, tokenB);
        require(poolAddress != address(0), "Pool does not exist");
        LiquidityPool pool = LiquidityPool(poolAddress);
        IERC20(tokenA).approve(poolAddress, amountOut);

        pool.swap(tokenA, tokenB, amountOut);
    }
    return amountOut; 
    }

}











// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "./IERC20.sol";
import "./ERC20.sol";

contract Staking {
    IERC20 public lpToken;
    IERC20 public rewardToken;
    uint256 public rewardPerSecond = 13;
    uint256 public allAmount = 0;
    mapping(address => uint256) public stakedAmount;
    mapping(address => uint256) public lastRewardTime;

    constructor(address _lpToken, address _rewardToken) {
        lpToken = IERC20(_lpToken);
        rewardToken = IERC20(_rewardToken);
    }

    function stake(uint256 amount) external {
        lpToken.transferFrom(msg.sender, address(this), amount);

        stakedAmount[msg.sender] += amount;
        allAmount += amount;
    }

    function withdraw(uint256 amount) external {
        lpToken.transfer(msg.sender, amount);

        stakedAmount[msg.sender] -= amount;
        allAmount -= amount;
    }

    function claimReward() external {
       uint256 timeDiff = block.timestamp - lastRewardTime[msg.sender];
       uint256 lpAmount = stakedAmount[msg.sender];
       uint256 rewardMultiplier = (timeDiff / 30 days) * 5 / 100 + 1; // Исправлено
       uint256 reward = lpAmount * timeDiff * rewardPerSecond * (lpAmount / allAmount + 1) * rewardMultiplier;
       rewardToken.transfer(msg.sender, reward);
       lastRewardTime[msg.sender] = block.timestamp;
    }
}