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: GPL-2.0-or-later
pragma solidity ^0.8.26;
interface IPair {
function totalSupply() external view returns (uint);
/// @notice calculate the current reserves of the pool and their last 'seen' timestamp
/// @return _reserve0 amount of token0 in reserves
/// @return _reserve1 amount of token1 in reserves
/// @return _blockTimestampLast the timestamp when the pool was last updated
function getReserves()
external
view
returns (
uint112 _reserve0,
uint112 _reserve1,
uint32 _blockTimestampLast
);
}
// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity ^0.8.26;
interface IRouter {
error EXPIRED();
error IDENTICAL();
error ZERO_ADDRESS();
error INSUFFICIENT_AMOUNT();
error INSUFFICIENT_LIQUIDITY();
error INSUFFICIENT_OUTPUT_AMOUNT();
error INVALID_PATH();
error INSUFFICIENT_B_AMOUNT();
error INSUFFICIENT_A_AMOUNT();
error EXCESSIVE_INPUT_AMOUNT();
error ETH_TRANSFER_FAILED();
error INVALID_RESERVES();
struct route {
/// @dev token from
address from;
/// @dev token to
address to;
/// @dev is stable route
bool stable;
}
function factory() external pure returns (address);
function WETH() external pure returns (address);
/// @notice sorts the tokens to see what the expected LP output would be for token0 and token1 (A/B)
/// @param tokenA the address of tokenA
/// @param tokenB the address of tokenB
/// @return token0 address of which becomes token0
/// @return token1 address of which becomes token1
function sortTokens(
address tokenA,
address tokenB
) external pure returns (address token0, address token1);
/// @notice calculates the CREATE2 address for a pair without making any external calls
/// @param tokenA the address of tokenA
/// @param tokenB the address of tokenB
/// @param stable if the pair is using the stable curve
/// @return pair address of the pair
function pairFor(
address tokenA,
address tokenB,
bool stable
) external view returns (address pair);
/// @notice fetches and sorts the reserves for a pair
/// @param tokenA the address of tokenA
/// @param tokenB the address of tokenB
/// @param stable if the pair is using the stable curve
/// @return reserveA get the reserves for tokenA
/// @return reserveB get the reserves for tokenB
function getReserves(
address tokenA,
address tokenB,
bool stable
) external view returns (uint256 reserveA, uint256 reserveB);
/// @notice performs chained getAmountOut calculations on any number of pairs
/// @param amountIn the amount of tokens of routes[0] to swap
/// @param routes the struct of the hops the swap should take
/// @return amounts uint array of the amounts out
function getAmountsOut(
uint256 amountIn,
route[] memory routes
) external view returns (uint256[] memory amounts);
/// @notice performs chained getAmountOut calculations on any number of pairs
/// @param amountIn amount of tokenIn
/// @param tokenIn address of the token going in
/// @param tokenOut address of the token coming out
/// @return amount uint amount out
/// @return stable if the curve used is stable or not
function getAmountOut(
uint256 amountIn,
address tokenIn,
address tokenOut
) external view returns (uint256 amount, bool stable);
/// @notice performs calculations to determine the expected state when adding liquidity
/// @param tokenA the address of tokenA
/// @param tokenB the address of tokenB
/// @param stable if the pair is using the stable curve
/// @param amountADesired amount of tokenA desired to be added
/// @param amountBDesired amount of tokenB desired to be added
/// @return amountA amount of tokenA added
/// @return amountB amount of tokenB added
/// @return liquidity liquidity value added
function quoteAddLiquidity(
address tokenA,
address tokenB,
bool stable,
uint256 amountADesired,
uint256 amountBDesired
)
external
view
returns (uint256 amountA, uint256 amountB, uint256 liquidity);
/// @param tokenA the address of tokenA
/// @param tokenB the address of tokenB
/// @param stable if the pair is using the stable curve
/// @param liquidity liquidity value to remove
/// @return amountA amount of tokenA removed
/// @return amountB amount of tokenB removed
function quoteRemoveLiquidity(
address tokenA,
address tokenB,
bool stable,
uint256 liquidity
) external view returns (uint256 amountA, uint256 amountB);
/// @param tokenA the address of tokenA
/// @param tokenB the address of tokenB
/// @param stable if the pair is using the stable curve
/// @param amountADesired amount of tokenA desired to be added
/// @param amountBDesired amount of tokenB desired to be added
/// @param amountAMin slippage for tokenA calculated from this param
/// @param amountBMin slippage for tokenB calculated from this param
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amountA amount of tokenA used
/// @return amountB amount of tokenB used
/// @return liquidity amount of liquidity minted
function addLiquidity(
address tokenA,
address tokenB,
bool stable,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
/// @param token the address of token
/// @param stable if the pair is using the stable curve
/// @param amountTokenDesired desired amount for token
/// @param amountTokenMin slippage for token
/// @param amountETHMin minimum amount of ETH added (slippage)
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amountToken amount of the token used
/// @return amountETH amount of ETH used
/// @return liquidity amount of liquidity minted
function addLiquidityETH(
address token,
bool stable,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
/// @param tokenA the address of tokenA
/// @param tokenB the address of tokenB
/// @param stable if the pair is using the stable curve
/// @param amountADesired amount of tokenA desired to be added
/// @param amountBDesired amount of tokenB desired to be added
/// @param amountAMin slippage for tokenA calculated from this param
/// @param amountBMin slippage for tokenB calculated from this param
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amountA amount of tokenA used
/// @return amountB amount of tokenB used
/// @return liquidity amount of liquidity minted
function addLiquidityAndStake(
address tokenA,
address tokenB,
bool stable,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
/// @notice adds liquidity to a legacy pair using ETH, and stakes it into a gauge on "to's" behalf
/// @param token the address of token
/// @param stable if the pair is using the stable curve
/// @param amountTokenDesired amount of token to be used
/// @param amountTokenMin slippage of token
/// @param amountETHMin slippage of ETH
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amountA amount of tokenA used
/// @return amountB amount of tokenB used
/// @return liquidity amount of liquidity minted
function addLiquidityETHAndStake(
address token,
bool stable,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountA, uint256 amountB, uint256 liquidity);
/// @param tokenA the address of tokenA
/// @param tokenB the address of tokenB
/// @param stable if the pair is using the stable curve
/// @param liquidity amount of LP tokens to remove
/// @param amountAMin slippage of tokenA
/// @param amountBMin slippage of tokenB
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amountA amount of tokenA used
/// @return amountB amount of tokenB used
function removeLiquidity(
address tokenA,
address tokenB,
bool stable,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
/// @param token address of the token
/// @param stable if the pair is using the stable curve
/// @param liquidity liquidity tokens to remove
/// @param amountTokenMin slippage of token
/// @param amountETHMin slippage of ETH
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amountToken amount of token used
/// @return amountETH amount of ETH used
function removeLiquidityETH(
address token,
bool stable,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
/// @param amountIn amount to send ideally
/// @param amountOutMin slippage of amount out
/// @param routes the hops the swap should take
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amounts amounts returned
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
route[] calldata routes,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
/// @param routes the hops the swap should take
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amounts amounts returned
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
route[] memory routes,
address to,
uint deadline
) external returns (uint256[] memory amounts);
/// @param amountOutMin slippage of token
/// @param routes the hops the swap should take
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amounts amounts returned
function swapExactETHForTokens(
uint256 amountOutMin,
route[] calldata routes,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
/// @param amountOut amount of tokens to get out
/// @param amountInMax max amount of tokens to put in to achieve amountOut (slippage)
/// @param routes the hops the swap should take
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amounts amounts returned
function swapTokensForExactETH(
uint amountOut,
uint amountInMax,
route[] calldata routes,
address to,
uint deadline
) external returns (uint256[] memory amounts);
/// @param amountIn amount of tokens to swap
/// @param amountOutMin slippage of token
/// @param routes the hops the swap should take
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amounts amounts returned
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
route[] calldata routes,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
/// @param amountOut exact amount out or revert
/// @param routes the hops the swap should take
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
/// @return amounts amounts returned
function swapETHForExactTokens(
uint amountOut,
route[] calldata routes,
address to,
uint deadline
) external payable returns (uint256[] memory amounts);
/// @param amountIn token amount to swap
/// @param amountOutMin slippage of token
/// @param routes the hops the swap should take
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
route[] calldata routes,
address to,
uint256 deadline
) external;
/// @param amountOutMin slippage of token
/// @param routes the hops the swap should take
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
route[] calldata routes,
address to,
uint256 deadline
) external payable;
/// @param amountIn token amount to swap
/// @param amountOutMin slippage of token
/// @param routes the hops the swap should take
/// @param to the address the liquidity tokens should be minted to
/// @param deadline timestamp deadline
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
route[] calldata routes,
address to,
uint256 deadline
) external;
/// @notice **** REMOVE LIQUIDITY (supporting fee-on-transfer tokens)****
/// @param token address of the token
/// @param stable if the swap curve is stable
/// @param liquidity liquidity value (lp tokens)
/// @param amountTokenMin slippage of token
/// @param amountETHMin slippage of ETH
/// @param to address to send to
/// @param deadline timestamp deadline
/// @return amountToken amount of token received
/// @return amountETH amount of ETH received
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
bool stable,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
}
// 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: UNLICENSED
pragma solidity ^0.8.24;
import "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "../interfaces/IRouter.sol";
import "../interfaces/IPair.sol";
import "../interfaces/IBurnToken.sol";
import "../interfaces/IToken.sol";
import "../interfaces/IManager.sol";
contract LPCreator is ReentrancyGuard {
IManager private Manager;
IBurnToken private BurnToken;
IToken private Token;
IPair private Pair;
IRouter private router;
address private wS;
uint256 public totalLPCreated;
uint256 private accSRewardPerToken;
uint256 private accTokenRewardPerToken;
bool public redemptionOpen;
struct UserInfos {
uint256 lpQty;
uint256 tokenDebt;
uint256 SDebt;
uint256 pendingTokenReward;
uint256 pendingSReward;
}
mapping(address => UserInfos) public userInfos;
constructor(address _manager) {
Manager = IManager(_manager);
router = IRouter(0x1D368773735ee1E678950B7A97bcA2CafB330CDc);
wS = router.WETH();
IERC20(wS).approve(address(router), type(uint256).max);
}
modifier onlyOwner() {
require(msg.sender == Manager.owner(), "Not authorized");
_;
}
function setManager(address _manager) external onlyOwner {
Manager = IManager(_manager);
}
function setRouter(address _router) external onlyOwner {
router = IRouter(_router);
}
function setPair(address _pair) external onlyOwner {
Pair = IPair(_pair);
}
function setRedemptionOpen(bool _redemptionOpen) external onlyOwner {
redemptionOpen = _redemptionOpen;
}
function addSRewards() external payable onlyOwner {
accSRewardPerToken += (msg.value * 1e18) / totalLPCreated;
}
function addTokenRewards(uint256 amount) external onlyOwner {
Token.transferFrom(msg.sender, address(this), amount);
accTokenRewardPerToken += (amount * 1e18) / totalLPCreated;
}
function update() external onlyOwner {
BurnToken = IBurnToken(_getContract("Burn"));
Token = IToken(_getContract("Token"));
Token.approve(address(router), type(uint256).max);
}
function addLp(uint256 wSAmount) external nonReentrant {
(uint256 _tokenAmount, uint256 _wSAmount, ) = router.quoteAddLiquidity(
address(Token),
wS,
false,
0,
wSAmount
);
require(
BurnToken.getLpPower(msg.sender) >= _tokenAmount,
"Insufficient LP Power"
);
Token.transferFrom(msg.sender, address(this), _tokenAmount);
IERC20(wS).transferFrom(msg.sender, address(this), _wSAmount);
(uint256 realAmount, uint256 realwSAmount, uint256 lpReceived) = router
.addLiquidity(
address(Token),
wS,
false,
_tokenAmount,
_wSAmount,
0,
0,
address(this),
block.timestamp + 2
);
BurnToken.manageLPPower(msg.sender, realAmount);
UserInfos storage _userInfo = userInfos[msg.sender];
(uint256 tokenRewards, uint256 SRewards) = _getPendingRewards(
msg.sender
);
if (tokenRewards > 0) {
_userInfo.pendingTokenReward += tokenRewards;
}
if (SRewards > 0) {
_userInfo.pendingSReward += SRewards;
}
_userInfo.lpQty += lpReceived;
_updateDebt(msg.sender);
totalLPCreated += lpReceived;
uint256 excessToken = _tokenAmount - realAmount;
if (excessToken > 1e9) {
Token.transfer(msg.sender, excessToken);
}
uint256 excessWS = wSAmount - realwSAmount;
if (excessWS > 1e9) {
(bool tmpSuccess, ) = payable(msg.sender).call{
value: excessWS,
gas: 30000
}("");
require(tmpSuccess, "Transfer failed");
}
}
function claim() external nonReentrant {
_claim(msg.sender);
}
function redemption() external nonReentrant {
require(redemptionOpen, "Redemption is closed");
_claim(msg.sender);
totalLPCreated -= userInfos[msg.sender].lpQty;
userInfos[msg.sender].lpQty = 0;
_updateDebt(msg.sender);
IERC20(address(Pair)).transfer(msg.sender, userInfos[msg.sender].lpQty);
}
function _claim(address sender) private {
(uint256 tokenRewards, uint256 SRewards) = _getPendingRewards(sender);
tokenRewards += userInfos[sender].pendingTokenReward;
SRewards += userInfos[sender].pendingSReward;
_updateDebt(sender);
if (tokenRewards > 0) {
userInfos[sender].pendingTokenReward = 0;
Token.transfer(sender, tokenRewards);
}
if (SRewards > 0) {
userInfos[sender].pendingSReward = 0;
bool tmpSuccess1;
(tmpSuccess1, ) = payable(sender).call{
value: SRewards,
gas: 500000
}("");
require(tmpSuccess1, "Transfer failed");
}
}
function _updateDebt(address account) private {
UserInfos storage _userInfo = userInfos[account];
_userInfo.tokenDebt = (_userInfo.lpQty * accTokenRewardPerToken) / 1e18;
_userInfo.SDebt = (_userInfo.lpQty * accSRewardPerToken) / 1e18;
}
/**
* @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
) private view returns (uint256, uint256) {
UserInfos memory _userInfo = userInfos[account];
return (
((_userInfo.lpQty * accTokenRewardPerToken) / 1e18) -
_userInfo.tokenDebt,
((_userInfo.lpQty * accSRewardPerToken) / 1e18) - _userInfo.SDebt
);
}
function getPendingRewards(
address account
) public view returns (uint256, uint256) {
(uint256 tokenRewards, uint256 SRewards) = _getPendingRewards(account);
return (
tokenRewards + userInfos[account].pendingTokenReward,
SRewards + userInfos[account].pendingSReward
);
}
function getTokenRequired(
uint256 wsAmount
) external view returns (uint256) {
(uint256 _tokenAmount, , ) = router.quoteAddLiquidity(
address(Token),
wS,
false,
0,
wsAmount
);
return _tokenAmount;
}
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 withdrawS(uint256 amount) external onlyOwner {
bool tmpSuccess1;
(tmpSuccess1, ) = payable(msg.sender).call{value: amount, gas: 5000000}(
""
);
require(tmpSuccess1, "Transfer failed");
}
}