Contract Name:
BridgersSwap
Contract Source Code:
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.18;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_setOwner(_msgSender());
}
function owner() public view virtual returns (address) {
return _owner;
}
modifier onlyOwner() {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
_;
}
function renounceOwnership() public virtual onlyOwner {
_setOwner(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_setOwner(newOwner);
}
function _setOwner(address newOwner) private {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
}
library TransferHelper {
function safeApprove(address token, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferHelper: APPROVE_FAILED");
}
function safeTransfer(address token, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferHelper: TRANSFER_FAILED");
}
function safeTransferFrom(address token, address from, address to, uint value) internal {
(bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
require(success && (data.length == 0 || abi.decode(data, (bool))), "TransferHelper: TRANSFER_FROM_FAILED");
}
function safeTransferETH(address to, uint value) internal {
(bool success, ) = to.call{value: value}(new bytes(0));
require(success, "TransferHelper: ETH_TRANSFER_FAILED");
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BridgersSwap is ReentrancyGuard, Ownable {
string public name;
string public symbol;
event Swap(
address fromToken,
string toToken,
address sender,
string destination,
uint256 fromAmount,
uint256 minReturnAmount
);
event SwapEth(string toToken, address sender, string destination, uint256 fromAmount, uint256 minReturnAmount);
event WithdrawETH(uint256 amount);
event Withdtraw(address token, uint256 amount);
constructor() {
name = "Bridgers Swap1.1";
symbol = "BridgersSwap";
}
function swap(
address fromToken,
string memory toToken,
string memory destination,
uint256 fromAmount,
uint256 minReturnAmount
) external nonReentrant {
require(fromToken != address(0), "FROMTOKEN_CANT_T_BE_0");
require(fromAmount > 0, "FROM_TOKEN_AMOUNT_MUST_BE_MORE_THAN_0");
uint256 _inputAmount;
uint256 _fromTokenBalanceOrigin = IERC20(fromToken).balanceOf(address(this));
TransferHelper.safeTransferFrom(fromToken, msg.sender, address(this), fromAmount);
uint256 _fromTokenBalanceNew = IERC20(fromToken).balanceOf(address(this));
_inputAmount = _fromTokenBalanceNew - _fromTokenBalanceOrigin;
require(_inputAmount > 0, "NO_FROM_TOKEN_TRANSFER_TO_THIS_CONTRACT");
emit Swap(fromToken, toToken, msg.sender, destination, fromAmount, minReturnAmount);
}
function swapEth(string memory toToken, string memory destination, uint256 minReturnAmount) external payable nonReentrant {
uint256 _ethAmount = msg.value;
require(_ethAmount > 0, "ETH_AMOUNT_MUST_BE_MORE_THAN_0");
emit SwapEth(toToken, msg.sender, destination, _ethAmount, minReturnAmount);
}
function withdrawETH(address destination, uint256 amount) external onlyOwner {
require(destination != address(0), "DESTINATION_CANNT_BE_0_ADDRESS");
uint256 balance = address(this).balance;
require(balance >= amount, "AMOUNT_CANNT_MORE_THAN_BALANCE");
TransferHelper.safeTransferETH(destination, amount);
emit WithdrawETH(amount);
}
function withdraw(address token, address destination, uint256 amount) external onlyOwner {
require(destination != address(0), "DESTINATION_CANNT_BE_0_ADDRESS");
require(token != address(0), "TOKEN_MUST_NOT_BE_0");
uint256 balance = IERC20(token).balanceOf(address(this));
require(balance >= amount, "AMOUNT_CANNT_MORE_THAN_BALANCE");
TransferHelper.safeTransfer(token, destination, amount);
emit Withdtraw(token, amount);
}
receive() external payable {}
}