Contract Source Code:
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
pragma solidity ^0.8.20;
/**
* @dev Interface of the ERC20 standard as defined in the EIP.
*/
interface IERC20 {
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
/**
* @dev Returns the value of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the value of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves a `value` amount of tokens from the caller's account to `to`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address to, uint256 value) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets a `value` amount of tokens as the allowance of `spender` over the
* caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 value) external returns (bool);
/**
* @dev Moves a `value` amount of tokens from `from` to `to` using the
* allowance mechanism. `value` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)
pragma solidity ^0.8.20;
/**
* @dev Contract module that helps prevent reentrant calls to a function.
*
* Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
* available, which can be applied to functions to make sure there are no nested
* (reentrant) calls to them.
*
* Note that because there is a single `nonReentrant` guard, functions marked as
* `nonReentrant` may not call one another. This can be worked around by making
* those functions `private`, and then adding `external` `nonReentrant` entry
* points to them.
*
* TIP: If you would like to learn more about reentrancy and alternative ways
* to protect against it, check out our blog post
* https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
*/
abstract contract ReentrancyGuard {
// Booleans are more expensive than uint256 or any type that takes up a full
// word because each write operation emits an extra SLOAD to first read the
// slot's contents, replace the bits taken up by the boolean, and then write
// back. This is the compiler's defense against contract upgrades and
// pointer aliasing, and it cannot be disabled.
// The values being non-zero value makes deployment a bit more expensive,
// but in exchange the refund on every call to nonReentrant will be lower in
// amount. Since refunds are capped to a percentage of the total
// transaction's gas, it is best to keep them low in cases like this one, to
// increase the likelihood of the full refund coming into effect.
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
uint256 private _status;
/**
* @dev Unauthorized reentrant call.
*/
error ReentrancyGuardReentrantCall();
constructor() {
_status = NOT_ENTERED;
}
/**
* @dev Prevents a contract from calling itself, directly or indirectly.
* Calling a `nonReentrant` function from another `nonReentrant`
* function is not supported. It is possible to prevent this from happening
* by making the `nonReentrant` function external, and making it call a
* `private` function that does the actual work.
*/
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
// On the first call to nonReentrant, _status will be NOT_ENTERED
if (_status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
// Any calls to nonReentrant after this point will fail
_status = ENTERED;
}
function _nonReentrantAfter() private {
// By storing the original value once again, a refund is triggered (see
// https://eips.ethereum.org/EIPS/eip-2200)
_status = NOT_ENTERED;
}
/**
* @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
* `nonReentrant` function in the call stack.
*/
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == ENTERED;
}
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IBurnToken is IERC20 {
function mint(address account, uint256 amount) external;
function manageLPPower(address sender, uint256 amount) external;
function getLpPower(address account) external view returns (uint256);
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.20;
interface IManager {
function getContract(string memory name) external view returns (address);
function owner() external view returns (address);
}
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
interface IToken is IERC20 {
function mint(address to, uint256 value) external;
function burnFrom(address account, uint256 value) external;
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.5.0;
interface IUniswapV2Pair {
function totalSupply() external view returns (uint);
function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
}
// SPDX-License-Identifier: MIT
pragma solidity >=0.6.2;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.24;
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "../interfaces/IUniswapV2Router02.sol";
import "../interfaces/IUniswapV2Pair.sol";
import "../interfaces/IBurnToken.sol";
import "../interfaces/IToken.sol";
import "../interfaces/IManager.sol";
contract LPCreator is ReentrancyGuard {
IManager private Manager;
IBurnToken private BurnToken;
IUniswapV2Pair private Pair;
IToken private Token;
IUniswapV2Router02 private router; // Uniswap V2 Router
uint256 public totalLPCreated;
uint256 private accETHRewardPerToken;
uint256 private accTokenRewardPerToken;
struct UserInfos {
uint256 lpQty;
uint256 tokenDebt;
uint256 ethDebt;
}
mapping(address => UserInfos) public userInfos;
/*------------------------------------*
CONSTRUCTOR
*------------------------------------*/
constructor(address _manager) {
Manager = IManager(_manager);
router = IUniswapV2Router02(0xCf5d764c542e77b6eBDe2f4c292fAF7487d3E296);
}
/*------------------------------------*
MODIFIERS
*------------------------------------*/
modifier onlyOwner() {
require(msg.sender == Manager.owner(), "Not authorized");
_;
}
/*------------------------------------*
SETTERS
*------------------------------------*/
function setManager(address _manager) external onlyOwner {
Manager = IManager(_manager);
}
function setRouter(address _router) external onlyOwner {
router = IUniswapV2Router02(_router);
}
function setPair(address _pair) external onlyOwner {
Pair = IUniswapV2Pair(_pair);
}
function addETHRewards() external payable onlyOwner {
accETHRewardPerToken += (msg.value * 1e18) / totalLPCreated;
}
function addTokenRewards(uint256 amount) external onlyOwner {
accTokenRewardPerToken += (amount * 1e18) / totalLPCreated;
}
function update() external onlyOwner {
BurnToken = IBurnToken(_getContract("Burn"));
Token = IToken(_getContract("Token"));
Token.approve(address(router), type(uint256).max);
}
/*------------------------------------*
FUNCTIONS
*------------------------------------*/
function addLp() external payable nonReentrant {
uint256 amountWETH = msg.value;
uint256 tokenAmount = getTokenRequired(amountWETH);
require(
BurnToken.getLpPower(msg.sender) >= tokenAmount,
"Insufficient LP Power"
);
Token.transferFrom(msg.sender, address(this), tokenAmount);
(uint256 realAmount, uint256 realETH, uint256 lpReceived) = router
.addLiquidityETH{value: amountWETH}(
address(Token),
tokenAmount,
0,
0,
address(this),
block.timestamp + 10 minutes
);
BurnToken.manageLPPower(msg.sender, realAmount);
UserInfos storage _userInfo = userInfos[msg.sender];
_userInfo.lpQty += lpReceived;
_userInfo.tokenDebt = (_userInfo.lpQty * accTokenRewardPerToken) / 1e18;
_userInfo.ethDebt = (_userInfo.lpQty * accETHRewardPerToken) / 1e18;
totalLPCreated += lpReceived;
uint256 excessToken = tokenAmount - realAmount;
if (excessToken > 1e9) {
Token.transfer(msg.sender, excessToken);
}
uint256 excessETH = msg.value - realETH;
if (excessETH > 1e9) {
(bool tmpSuccess, ) = payable(msg.sender).call{
value: excessETH,
gas: 30000
}("");
require(tmpSuccess, "Transfer failed");
}
}
function claim() external nonReentrant {
_claim(msg.sender);
}
/*------------------------------------*
INTERNAL
*------------------------------------*/
function _claim(address sender) private {
(uint256 tokenRewards, uint256 ethRewards) = getPendingRewards(sender);
if (tokenRewards > 0) {
Token.transfer(sender, tokenRewards);
}
if (ethRewards > 0) {
bool tmpSuccess1;
(tmpSuccess1, ) = payable(sender).call{
value: ethRewards,
gas: 500000
}("");
require(tmpSuccess1, "Transfer failed");
}
}
/*------------------------------------*
GETTERS
*------------------------------------*/
/**
* @dev Get LP value in ETH of an account
* @param account Account address
*/
function getLPValue(address account) external view returns (uint256) {
(uint112 reserveETH, , ) = Pair.getReserves();
uint256 pairSupply = Pair.totalSupply();
return (userInfos[account].lpQty * reserveETH) / pairSupply;
}
function getPendingRewards(
address account
) public view returns (uint256, uint256) {
UserInfos memory _userInfo = userInfos[account];
return (
(_userInfo.lpQty * accTokenRewardPerToken) / 1e18,
(_userInfo.lpQty * accETHRewardPerToken) / 1e18
);
}
function getTokenRequired(uint256 ETHAmount) public view returns (uint256) {
(uint256 reserveToken, uint256 reserveWETH, ) = Pair.getReserves();
return router.quote(ETHAmount, reserveWETH, reserveToken);
}
/*------------------------------------*
UTILS
*------------------------------------*/
function _getContract(string memory name) internal view returns (address) {
return Manager.getContract(name);
}
function withdrawERC20(address token, uint256 amount) external onlyOwner {
IToken(token).transfer(msg.sender, amount);
}
function withdrawETH(uint256 amount) external onlyOwner {
bool tmpSuccess1;
(tmpSuccess1, ) = payable(msg.sender).call{value: amount, gas: 5000000}(
""
);
require(tmpSuccess1, "Transfer failed");
}
}