文件 8 的 12：SafeTransferLib.sol
pragma solidity ^0.8.4;
library SafeTransferLib {
error ETHTransferFailed();
error TransferFromFailed();
error TransferFailed();
error ApproveFailed();
error Permit2Failed();
error Permit2AmountOverflow();
uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;
uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;
bytes32 internal constant DAI_DOMAIN_SEPARATOR =
0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;
address internal constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
function safeTransferETH(address to, uint256 amount) internal {
assembly {
if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
}
}
function safeTransferAllETH(address to) internal {
assembly {
if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
}
}
function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
assembly {
if lt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {
assembly {
if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function forceSafeTransferETH(address to, uint256 amount) internal {
assembly {
if lt(selfbalance(), amount) {
mstore(0x00, 0xb12d13eb)
revert(0x1c, 0x04)
}
if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function forceSafeTransferAllETH(address to) internal {
assembly {
if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
mstore(0x00, to)
mstore8(0x0b, 0x73)
mstore8(0x20, 0xff)
if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) }
}
}
}
function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
internal
returns (bool success)
{
assembly {
success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)
}
}
function trySafeTransferAllETH(address to, uint256 gasStipend)
internal
returns (bool success)
{
assembly {
success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)
}
}
function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
assembly {
let m := mload(0x40)
mstore(0x60, amount)
mstore(0x40, to)
mstore(0x2c, shl(96, from))
mstore(0x0c, 0x23b872dd000000000000000000000000)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
) {
mstore(0x00, 0x7939f424)
revert(0x1c, 0x04)
}
mstore(0x60, 0)
mstore(0x40, m)
}
}
function trySafeTransferFrom(address token, address from, address to, uint256 amount)
internal
returns (bool success)
{
assembly {
let m := mload(0x40)
mstore(0x60, amount)
mstore(0x40, to)
mstore(0x2c, shl(96, from))
mstore(0x0c, 0x23b872dd000000000000000000000000)
success :=
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
mstore(0x60, 0)
mstore(0x40, m)
}
}
function safeTransferAllFrom(address token, address from, address to)
internal
returns (uint256 amount)
{
assembly {
let m := mload(0x40)
mstore(0x40, to)
mstore(0x2c, shl(96, from))
mstore(0x0c, 0x70a08231000000000000000000000000)
if iszero(
and(
gt(returndatasize(), 0x1f),
staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
)
) {
mstore(0x00, 0x7939f424)
revert(0x1c, 0x04)
}
mstore(0x00, 0x23b872dd)
amount := mload(0x60)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
)
) {
mstore(0x00, 0x7939f424)
revert(0x1c, 0x04)
}
mstore(0x60, 0)
mstore(0x40, m)
}
}
function safeTransfer(address token, address to, uint256 amount) internal {
assembly {
mstore(0x14, to)
mstore(0x34, amount)
mstore(0x00, 0xa9059cbb000000000000000000000000)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x90b8ec18)
revert(0x1c, 0x04)
}
mstore(0x34, 0)
}
}
function safeTransferAll(address token, address to) internal returns (uint256 amount) {
assembly {
mstore(0x00, 0x70a08231)
mstore(0x20, address())
if iszero(
and(
gt(returndatasize(), 0x1f),
staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
)
) {
mstore(0x00, 0x90b8ec18)
revert(0x1c, 0x04)
}
mstore(0x14, to)
amount := mload(0x34)
mstore(0x00, 0xa9059cbb000000000000000000000000)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x90b8ec18)
revert(0x1c, 0x04)
}
mstore(0x34, 0)
}
}
function safeApprove(address token, address to, uint256 amount) internal {
assembly {
mstore(0x14, to)
mstore(0x34, amount)
mstore(0x00, 0x095ea7b3000000000000000000000000)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x3e3f8f73)
revert(0x1c, 0x04)
}
mstore(0x34, 0)
}
}
function safeApproveWithRetry(address token, address to, uint256 amount) internal {
assembly {
mstore(0x14, to)
mstore(0x34, amount)
mstore(0x00, 0x095ea7b3000000000000000000000000)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x34, 0)
mstore(0x00, 0x095ea7b3000000000000000000000000)
pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00))
mstore(0x34, amount)
if iszero(
and(
or(eq(mload(0x00), 1), iszero(returndatasize())),
call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
)
) {
mstore(0x00, 0x3e3f8f73)
revert(0x1c, 0x04)
}
}
mstore(0x34, 0)
}
}
function balanceOf(address token, address account) internal view returns (uint256 amount) {
assembly {
mstore(0x14, account)
mstore(0x00, 0x70a08231000000000000000000000000)
amount :=
mul(
mload(0x20),
and(
gt(returndatasize(), 0x1f),
staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
)
)
}
}
function safeTransferFrom2(address token, address from, address to, uint256 amount) internal {
if (!trySafeTransferFrom(token, from, to, amount)) {
permit2TransferFrom(token, from, to, amount);
}
}
function permit2TransferFrom(address token, address from, address to, uint256 amount)
internal
{
assembly {
let m := mload(0x40)
mstore(add(m, 0x74), shr(96, shl(96, token)))
mstore(add(m, 0x54), amount)
mstore(add(m, 0x34), to)
mstore(add(m, 0x20), shl(96, from))
mstore(m, 0x36c78516000000000000000000000000)
let p := PERMIT2
let exists := eq(chainid(), 1)
if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }
if iszero(and(call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00), exists)) {
mstore(0x00, 0x7939f4248757f0fd)
revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)
}
}
}
function permit2(
address token,
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
bool success;
assembly {
for {} shl(96, xor(token, WETH9)) {} {
mstore(0x00, 0x3644e515)
if iszero(
and(
lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)),
staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)
)
) { break }
let m := mload(0x40)
mstore(add(m, 0x34), spender)
mstore(add(m, 0x20), shl(96, owner))
mstore(add(m, 0x74), deadline)
if eq(mload(0x00), DAI_DOMAIN_SEPARATOR) {
mstore(0x14, owner)
mstore(0x00, 0x7ecebe00000000000000000000000000)
mstore(add(m, 0x94), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))
mstore(m, 0x8fcbaf0c000000000000000000000000)
mstore(add(m, 0xb4), and(0xff, v))
mstore(add(m, 0xd4), r)
mstore(add(m, 0xf4), s)
success := call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)
break
}
mstore(m, 0xd505accf000000000000000000000000)
mstore(add(m, 0x54), amount)
mstore(add(m, 0x94), and(0xff, v))
mstore(add(m, 0xb4), r)
mstore(add(m, 0xd4), s)
success := call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)
break
}
}
if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);
}
function simplePermit2(
address token,
address owner,
address spender,
uint256 amount,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
assembly {
let m := mload(0x40)
mstore(m, 0x927da105)
{
let addressMask := shr(96, not(0))
mstore(add(m, 0x20), and(addressMask, owner))
mstore(add(m, 0x40), and(addressMask, token))
mstore(add(m, 0x60), and(addressMask, spender))
mstore(add(m, 0xc0), and(addressMask, spender))
}
let p := mul(PERMIT2, iszero(shr(160, amount)))
if iszero(
and(
gt(returndatasize(), 0x5f),
staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)
)
) {
mstore(0x00, 0x6b836e6b8757f0fd)
revert(add(0x18, shl(2, iszero(p))), 0x04)
}
mstore(m, 0x2b67b570)
mstore(add(m, 0x60), amount)
mstore(add(m, 0x80), 0xffffffffffff)
mstore(add(m, 0xe0), deadline)
mstore(add(m, 0x100), 0x100)
mstore(add(m, 0x120), 0x41)
mstore(add(m, 0x140), r)
mstore(add(m, 0x160), s)
mstore(add(m, 0x180), shl(248, v))
if iszero(call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00)) {
mstore(0x00, 0x6b836e6b)
revert(0x1c, 0x04)
}
}
}
}
文件 9 的 12：g8keepFactory.sol
pragma solidity 0.8.20;
import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
import {Ownable} from "solady/auth/Ownable.sol";
import {g8keepToken} from "./g8keepToken.sol";
import {g8keepPenaltyReceiver} from "./g8keepPenaltyReceiver.sol";
import {g8keepFactoryConfiguration} from "./g8keepFactoryConfiguration.sol";
import {IUniswapV2Router02} from "./interfaces/IUniswapV2Router02.sol";
import {IUniswapV2Pair} from "./interfaces/IUniswapV2Pair.sol";
import {IG8keepFactory} from "./interfaces/IG8keepFactory.sol";
import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
contract g8keepFactory is IG8keepFactory, Ownable {
address public immutable WETH;
address public immutable UNISWAP_V2_ROUTER;
address public g8keepTokenVesting;
address public g8keepFeeWallet;
address public penaltyReceiver;
uint16 public g8keepFee = 100;
uint16 public g8keepInitialLiquidityFee = 200;
uint16 public maxBuyFee = 500;
uint16 public maxSellFee = 500;
uint24 public minimumDeployVestTime = 1 days;
uint24 public minimumSnipeProtectionSeconds = 30 minutes;
uint24 public maximumSnipeProtectionSeconds = 30 days;
uint24 public minimumHeavySnipeProtectionSeconds = 30 minutes;
uint24 public maximumHeavySnipeProtectionSeconds = 1 days;
uint8 public minimumHeavySnipeExponent = 20;
uint8 public maximumHeavySnipeExponent = 60;
uint16 private constant MAX_SETTING_G8KEEP_FEE = 100;
uint16 private constant MAX_SETTING_G8KEEP_INITIAL_LIQUIDITY_FEE = 200;
uint16 private constant MAX_SETTING_BUY_FEE = 500;
uint16 private constant MAX_SETTING_SELL_FEE = 500;
uint40 private constant MAX_SETTING_MINIMUM_DEPLOY_VEST_TIME = 90 days;
uint40 private constant MAX_SETTING_MINIMUM_SNIPE_PROTECTION_SECONDS = 7 days;
uint40 private constant MAX_SETTING_MAXIMUM_SNIPE_PROTECTION_SECONDS = 365 days;
uint40 private constant MAX_SETTING_MINIMUM_HEAVY_SNIPE_PROTECTION_SECONDS = 1 days;
uint40 private constant MAX_SETTING_MAXIMUM_HEAVY_SNIPE_PROTECTION_SECONDS = 5 days;
uint8 private constant MIN_SETTING_MINIMUM_HEAVY_SNIPE_EXPONENT = 2;
uint8 private constant MAX_SETTING_MINIMUM_HEAVY_SNIPE_EXPONENT = 20;
uint8 private constant MAX_SETTING_MAXIMUM_HEAVY_SNIPE_EXPONENT = 100;
uint16 private constant BPS = 10_000;
mapping(address => bool) public allowedPairs;
mapping(address => uint256) public pairedTokenMinimumLiquidity;
mapping(address => bool) private lockedTokens;
event TokenDeployed(
address indexed token,
address indexed pair,
address indexed deployer,
string symbol
);
event DeploymentSettingsUpdated(
uint16 maxBuyFee,
uint16 maxSellFee,
uint24 minimumDeployVestTime,
uint24 minimumSnipeProtectionSeconds,
uint24 maximumSnipeProtectionSeconds,
uint24 minimumHeavySnipeProtectionSeconds,
uint24 maximumHeavySnipeProtectionSeconds,
uint8 minimumHeavySnipeExponent,
uint8 maximumHeavySnipeExponent
);
event PairedTokenSettingsUpdated(
address indexed pairedToken,
bool allowed,
uint256 minimumLiquidity
);
event PenaltyReceiverUpdated(
address indexed penaltyReceiver
);
error ArrayLengthMismatch();
error DeadlinePassed();
error FailedToDepositWETH();
error InvalidDeploymentParameters();
error InvalidSettings();
error NotEnoughInitialLiquidity();
error PairNotAllowed();
error TokenLocked();
error ValueNotAllowedForNonWETHPairs();
error ValueSentNotValid();
error WithdrawalFailed();
error ZeroAddress();
struct TokenSale {
address tokenAddress;
uint256 amountToSell;
uint256 amountOutMin;
address recipient;
}
constructor(address _g8keepFactoryConfiguration) {
g8keepFactoryConfiguration config = g8keepFactoryConfiguration(_g8keepFactoryConfiguration);
(
address _defaultOwner,
address _g8keepFeeWallet,
address _uniswapV2Router,
address _WETH,
uint256 _minimumWETHLiquidity
) = config.getFactoryConfiguration();
if (
_defaultOwner == address(0)
|| _g8keepFeeWallet == address(0)
|| _uniswapV2Router == address(0)
|| _WETH == address(0)
) {
revert ZeroAddress();
}
_initializeOwner(_defaultOwner);
allowedPairs[_WETH] = true;
pairedTokenMinimumLiquidity[_WETH] = _minimumWETHLiquidity;
WETH = _WETH;
UNISWAP_V2_ROUTER = _uniswapV2Router;
g8keepFeeWallet = _g8keepFeeWallet;
penaltyReceiver = address(new g8keepPenaltyReceiver(_defaultOwner));
SafeTransferLib.safeApprove(_WETH, _uniswapV2Router, type(uint256).max);
}
function deployToken(
uint256 _initialLiquidity,
string memory _name,
string memory _symbol,
uint256 _totalSupply,
address _treasuryWallet,
uint16 _buyFee,
uint16 _sellFee,
address _pairedToken,
uint256 _deployReserve,
uint256 _deployVestTime,
uint256 _snipeProtectionSeconds,
uint256 _heavySnipeSeconds,
uint256 _heavySnipeExponent,
bytes32 _tokenSalt
) external payable returns (address _tokenAddress) {
if (!allowedPairs[_pairedToken]) revert PairNotAllowed();
if (
_buyFee > maxBuyFee || _sellFee > maxSellFee || _deployVestTime < minimumDeployVestTime
|| (_deployVestTime > 0 && g8keepTokenVesting == address(0))
|| _snipeProtectionSeconds < minimumSnipeProtectionSeconds
|| _snipeProtectionSeconds > maximumSnipeProtectionSeconds
|| _heavySnipeSeconds < minimumHeavySnipeProtectionSeconds
|| _heavySnipeSeconds > maximumHeavySnipeProtectionSeconds
|| _heavySnipeExponent < minimumHeavySnipeExponent
|| _heavySnipeExponent > maximumHeavySnipeExponent
|| lockedTokens[_pairedToken]
|| _treasuryWallet == address(0)
) {
revert InvalidDeploymentParameters();
}
if (_pairedToken == WETH) {
if (msg.value > _initialLiquidity) {
revert ValueSentNotValid();
}
if (msg.value > 0) {
(bool success,) = WETH.call{value: msg.value}("");
if (!success) revert FailedToDepositWETH();
}
if (msg.value < _initialLiquidity) {
unchecked {
SafeTransferLib.safeTransferFrom(
WETH,
msg.sender,
address(this),
_initialLiquidity - msg.value
);
}
}
} else if (msg.value > 0) {
revert ValueNotAllowedForNonWETHPairs();
} else {
uint256 balanceBefore = IERC20(_pairedToken).balanceOf(address(this));
SafeTransferLib.safeTransferFrom(_pairedToken, msg.sender, address(this), _initialLiquidity);
uint256 balanceAfter = IERC20(_pairedToken).balanceOf(address(this));
if (balanceAfter > balanceBefore) {
unchecked {
_initialLiquidity = balanceAfter - balanceBefore;
}
} else {
_initialLiquidity = 0;
}
}
g8keepToken token = new g8keepToken{salt: _tokenSalt}(
msg.sender,
_name,
_symbol,
_totalSupply,
_treasuryWallet,
penaltyReceiver,
_buyFee,
_sellFee,
g8keepFee,
UNISWAP_V2_ROUTER,
_pairedToken,
_deployReserve,
_deployVestTime,
_snipeProtectionSeconds,
_heavySnipeSeconds,
_heavySnipeExponent
);
address pairAddress = token.UNISWAP_V2_PAIR();
if (IERC20(_pairedToken).balanceOf(pairAddress) > 0) {
uint256 balanceBefore = IERC20(_pairedToken).balanceOf(address(this));
IUniswapV2Pair(pairAddress).skim(address(this));
uint256 balanceAfter = IERC20(_pairedToken).balanceOf(address(this));
if (balanceAfter > balanceBefore) {
unchecked {
_initialLiquidity = _initialLiquidity + balanceAfter - balanceBefore;
}
}
}
if (_initialLiquidity < pairedTokenMinimumLiquidity[_pairedToken]) revert NotEnoughInitialLiquidity();
lockedTokens[pairAddress] = true;
uint256 valueToG8keep = (_initialLiquidity * g8keepInitialLiquidityFee) / BPS;
if (valueToG8keep > 0) {
SafeTransferLib.safeTransfer(_pairedToken, g8keepFeeWallet, valueToG8keep);
}
IUniswapV2Router02(UNISWAP_V2_ROUTER).addLiquidity(
_pairedToken,
address(token),
_initialLiquidity - valueToG8keep,
token.balanceOf(address(this)),
0,
0,
address(this),
block.timestamp
);
emit TokenDeployed(address(token), pairAddress, msg.sender, _symbol);
return address(token);
}
function setPairedTokenSettings(
address pairedToken,
bool allowed,
uint256 minimumLiquidity
) external onlyOwner {
uint256 allowanceAmount;
if (allowed) {
allowanceAmount = type(uint256).max;
}
_setPairedTokenSettings(pairedToken, allowed, minimumLiquidity, allowanceAmount);
}
function setPairedTokenSettingsWithAllowance(
address pairedToken,
bool allowed,
uint256 minimumLiquidity,
uint256 allowanceAmount
) external onlyOwner {
_setPairedTokenSettings(pairedToken, allowed, minimumLiquidity, allowanceAmount);
}
function setDeploymentSettings(
uint16 _maxBuyFee,
uint16 _maxSellFee,
uint24 _minimumDeployVestTime,
uint24 _minimumSnipeProtectionSeconds,
uint24 _maximumSnipeProtectionSeconds,
uint24 _minimumHeavySnipeProtectionSeconds,
uint24 _maximumHeavySnipeProtectionSeconds,
uint8 _minimumHeavySnipeExponent,
uint8 _maximumHeavySnipeExponent
) external onlyOwner {
if (
_maxBuyFee > MAX_SETTING_BUY_FEE || _maxSellFee > MAX_SETTING_SELL_FEE
|| _minimumDeployVestTime > MAX_SETTING_MINIMUM_DEPLOY_VEST_TIME
|| (_minimumDeployVestTime > 0 && g8keepTokenVesting == address(0))
|| _minimumSnipeProtectionSeconds > MAX_SETTING_MINIMUM_SNIPE_PROTECTION_SECONDS
|| _maximumSnipeProtectionSeconds > MAX_SETTING_MAXIMUM_SNIPE_PROTECTION_SECONDS
|| _minimumSnipeProtectionSeconds > _maximumSnipeProtectionSeconds
|| _minimumHeavySnipeProtectionSeconds > MAX_SETTING_MINIMUM_HEAVY_SNIPE_PROTECTION_SECONDS
|| _maximumHeavySnipeProtectionSeconds > MAX_SETTING_MAXIMUM_HEAVY_SNIPE_PROTECTION_SECONDS
|| _minimumHeavySnipeProtectionSeconds > _maximumHeavySnipeProtectionSeconds
|| _minimumHeavySnipeExponent < MIN_SETTING_MINIMUM_HEAVY_SNIPE_EXPONENT
|| _minimumHeavySnipeExponent > MAX_SETTING_MINIMUM_HEAVY_SNIPE_EXPONENT
|| _maximumHeavySnipeExponent > MAX_SETTING_MAXIMUM_HEAVY_SNIPE_EXPONENT
|| _minimumHeavySnipeExponent > _maximumHeavySnipeExponent
) {
revert InvalidSettings();
}
maxBuyFee = _maxBuyFee;
maxSellFee = _maxSellFee;
minimumDeployVestTime = _minimumDeployVestTime;
minimumSnipeProtectionSeconds = _minimumSnipeProtectionSeconds;
maximumSnipeProtectionSeconds = _maximumSnipeProtectionSeconds;
minimumHeavySnipeProtectionSeconds = _minimumHeavySnipeProtectionSeconds;
maximumHeavySnipeProtectionSeconds = _maximumHeavySnipeProtectionSeconds;
minimumHeavySnipeExponent = _minimumHeavySnipeExponent;
maximumHeavySnipeExponent = _maximumHeavySnipeExponent;
emit DeploymentSettingsUpdated(
_maxBuyFee,
_maxSellFee,
_minimumDeployVestTime,
_minimumSnipeProtectionSeconds,
_maximumSnipeProtectionSeconds,
_minimumHeavySnipeProtectionSeconds,
_maximumHeavySnipeProtectionSeconds,
_minimumHeavySnipeExponent,
_maximumHeavySnipeExponent
);
}
function setG8keepFee(uint16 _g8keepFee) external onlyOwner {
if (_g8keepFee > MAX_SETTING_G8KEEP_FEE) {
revert InvalidSettings();
}
g8keepFee = _g8keepFee;
}
function setG8keepInitialLiquidityFee(uint16 _g8keepInitialLiquidityFee) external onlyOwner {
if (_g8keepInitialLiquidityFee > MAX_SETTING_G8KEEP_INITIAL_LIQUIDITY_FEE) {
revert InvalidSettings();
}
g8keepInitialLiquidityFee = _g8keepInitialLiquidityFee;
}
function setG8keepTokenVestingAddress(address _g8keepTokenVesting) external onlyOwner {
if (_g8keepTokenVesting == address(0) && minimumDeployVestTime > 0) {
revert InvalidSettings();
}
g8keepTokenVesting = _g8keepTokenVesting;
}
function setG8keepFeeWallet(address _g8keepFeeWallet) external onlyOwner {
if (_g8keepFeeWallet == address(0)) {
revert ZeroAddress();
}
g8keepFeeWallet = _g8keepFeeWallet;
}
function setPenaltyReceiver(address _penaltyReceiver) external onlyOwner {
if (_penaltyReceiver == address(0)) {
revert ZeroAddress();
}
address currentPenaltyReceiver = penaltyReceiver;
if (currentPenaltyReceiver == _penaltyReceiver) {
revert InvalidSettings();
}
penaltyReceiver = _penaltyReceiver;
emit PenaltyReceiverUpdated(_penaltyReceiver);
}
function setApprovalToUniswapRouter(
address[] calldata tokenAddresses,
bool[] calldata approved,
uint256 approvalRevokeAmount
) external onlyOwner {
if (tokenAddresses.length != approved.length) {
revert ArrayLengthMismatch();
}
for (uint256 i; i < tokenAddresses.length; ++i) {
address tokenAddress = tokenAddresses[i];
if (lockedTokens[tokenAddress]) continue;
if (approved[i]) {
SafeTransferLib.safeApproveWithRetry(tokenAddress, UNISWAP_V2_ROUTER, type(uint256).max);
} else {
SafeTransferLib.safeApproveWithRetry(tokenAddress, UNISWAP_V2_ROUTER, approvalRevokeAmount);
}
}
}
function sellTokens(TokenSale[] calldata sellParameters, uint256 deadline) external onlyOwner {
if (deadline < block.timestamp) {
revert DeadlinePassed();
}
for (uint256 i; i < sellParameters.length; ++i) {
TokenSale calldata sale = sellParameters[i];
address tokenAddress = sale.tokenAddress;
if (lockedTokens[tokenAddress]) {
continue;
}
if (sale.recipient == address(0)) {
revert ZeroAddress();
}
address[] memory path = new address[](2);
path[0] = tokenAddress;
path[1] = g8keepToken(tokenAddress).PAIRED_TOKEN();
try IUniswapV2Router02(UNISWAP_V2_ROUTER).swapExactTokensForTokensSupportingFeeOnTransferTokens(
sale.amountToSell, sale.amountOutMin, path, sale.recipient, block.timestamp
) {} catch {}
}
}
function withdrawToken(address tokenAddress, address to) external onlyOwner {
if (lockedTokens[tokenAddress]) {
revert TokenLocked();
}
uint256 _contractBalance = IERC20(tokenAddress).balanceOf(address(this));
SafeTransferLib.safeTransfer(tokenAddress, to, _contractBalance);
}
function withdrawToken(address tokenAddress, address to, uint256 amount) external onlyOwner {
if (lockedTokens[tokenAddress]) {
revert TokenLocked();
}
SafeTransferLib.safeTransfer(tokenAddress, to, amount);
}
function withdrawETH(address to) external onlyOwner {
if (to == address(0)) revert ZeroAddress();
(bool success,) = to.call{value: address(this).balance}("");
if (!success) revert WithdrawalFailed();
}
function _setPairedTokenSettings(address pairedToken, bool allowed, uint256 minimumLiquidity, uint256 allowanceAmount) internal {
if (lockedTokens[pairedToken]) revert TokenLocked();
allowedPairs[pairedToken] = allowed;
pairedTokenMinimumLiquidity[pairedToken] = minimumLiquidity;
SafeTransferLib.safeApproveWithRetry(pairedToken, UNISWAP_V2_ROUTER, allowanceAmount);
emit PairedTokenSettingsUpdated(
pairedToken,
allowed,
minimumLiquidity
);
}
}文件 12 的 12：g8keepToken.sol
pragma solidity 0.8.20;
import {Ownable} from "solady/auth/Ownable.sol";
import {IERC20} from "openzeppelin-contracts/contracts/token/ERC20/IERC20.sol";
import {IUniswapV2Router02} from "./interfaces/IUniswapV2Router02.sol";
import {IUniswapV2Factory} from "./interfaces/IUniswapV2Factory.sol";
import {IUniswapV2Pair} from "./interfaces/IUniswapV2Pair.sol";
import {IG8keepDeployerVesting} from "./interfaces/IG8keepDeployerVesting.sol";
import {IG8keepFactory} from "./interfaces/IG8keepFactory.sol";
import {SafeTransferLib} from "solady/utils/SafeTransferLib.sol";
contract g8keepToken is Ownable {
string public name;
string public symbol;
uint8 public constant decimals = 18;
uint256 public immutable totalSupply;
address private immutable G8KEEP;
address private immutable PENALTY_TAX_RECEIVER;
address public immutable UNISWAP_V2_PAIR;
address public immutable PAIRED_TOKEN;
uint16 private constant BPS = 10_000;
uint16 private constant MAX_DEPLOYER_RESERVE = 300;
uint40 private immutable GENESIS_TIME;
uint8 private constant SNIPE_PENALTY_BASE_EXPONENT = 2;
uint40 public immutable SNIPE_PROTECTION_SECONDS;
uint40 public immutable SNIPE_PROTECTION_END;
uint8 public immutable SNIPE_PROTECTION_HEAVY_EXPONENT_START;
uint40 public immutable SNIPE_PROTECTION_HEAVY_PENALTY_SECONDS;
uint16 public immutable G8KEEP_FEE;
uint16 public buyFee;
uint16 public sellFee;
address public treasuryWallet;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private lpBalanceBaseline;
uint256 private lastLPTotalSupply;
uint112 private thirdPartyLPAmount;
uint112 private cachedLPReserve1;
error CannotBurnLiquidityDuringSnipeProtection();
error CannotIncreaseFees();
error CannotTransferFromAndToUniswapV2Pair();
error ExcessiveAmountOut();
error InsufficientAllowance();
error InsufficientBalance();
error InsufficientPoolInput();
error InvalidHeavySnipeParameters();
error InvalidReserves();
error InvalidTokenAddress();
error ReserveExceedsMax();
error SnipeProtectionTimeOverflow();
error InvalidTreasuryAddress();
error SupplyExceedsMax();
error ZeroAddress();
event Approval(address indexed owner, address indexed spender, uint256 value);
event DeployerFeesUpdated(uint16 buyFee, uint16 sellFee);
event Transfer(address indexed from, address indexed to, uint256 value);
event TreasuryWalletUpdated(address treasuryWallet);
constructor(
address _deployer,
string memory _name,
string memory _symbol,
uint256 _totalSupply,
address _treasuryWallet,
address _penaltyTaxReceiver,
uint16 _buyFee,
uint16 _sellFee,
uint16 _g8keepFee,
address _uniswapV2Router,
address _pairedToken,
uint256 _deployReserve,
uint256 _deployVestTime,
uint256 _snipeProtectionSeconds,
uint256 _heavySnipeSeconds,
uint256 _heavySnipeExponent
) {
if (_deployReserve > MAX_DEPLOYER_RESERVE) revert ReserveExceedsMax();
if (_snipeProtectionSeconds + block.timestamp > type(uint40).max || _heavySnipeSeconds > _snipeProtectionSeconds) revert SnipeProtectionTimeOverflow();
if (_totalSupply > type(uint112).max) revert SupplyExceedsMax();
if (_heavySnipeExponent > type(uint8).max || _heavySnipeExponent < SNIPE_PENALTY_BASE_EXPONENT) revert InvalidHeavySnipeParameters();
_initializeOwner(_deployer);
G8KEEP = msg.sender;
PENALTY_TAX_RECEIVER = _penaltyTaxReceiver;
GENESIS_TIME = uint40(block.timestamp);
SNIPE_PROTECTION_SECONDS = uint40(_snipeProtectionSeconds);
SNIPE_PROTECTION_END = uint40(_snipeProtectionSeconds + block.timestamp);
G8KEEP_FEE = _g8keepFee;
PAIRED_TOKEN = _pairedToken;
SNIPE_PROTECTION_HEAVY_PENALTY_SECONDS = uint40(_heavySnipeSeconds);
SNIPE_PROTECTION_HEAVY_EXPONENT_START = uint8(_heavySnipeExponent - SNIPE_PENALTY_BASE_EXPONENT);
buyFee = _buyFee;
sellFee = _sellFee;
if (uint160(address(this)) < uint160(_pairedToken)) {
revert InvalidTokenAddress();
}
name = _name;
symbol = _symbol;
totalSupply = _totalSupply;
treasuryWallet = _treasuryWallet;
IUniswapV2Router02 uniswapV2Router = IUniswapV2Router02(_uniswapV2Router);
address uniswapV2Pair;
try
IUniswapV2Factory(uniswapV2Router.factory()).createPair(_pairedToken, address(this))
returns (address _uniswapV2Pair) {
uniswapV2Pair = _uniswapV2Pair;
} catch {
uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).getPair(_pairedToken, address(this));
}
UNISWAP_V2_PAIR = uniswapV2Pair;
if (_treasuryWallet == uniswapV2Pair) {
revert InvalidTreasuryAddress();
}
uint256 tokensToDeployer = _totalSupply * _deployReserve / BPS;
uint256 tokensToLP = _totalSupply - tokensToDeployer;
lpBalanceBaseline = tokensToLP;
_balances[msg.sender] = tokensToLP;
emit Transfer(address(0), msg.sender, tokensToLP);
_allowances[msg.sender][_uniswapV2Router] = type(uint256).max;
emit Approval(msg.sender, _uniswapV2Router, type(uint256).max);
if (tokensToDeployer > 0) {
if (_deployVestTime == 0) {
_balances[_deployer] = tokensToDeployer;
emit Transfer(address(0), _deployer, tokensToDeployer);
} else {
address g8keepVester = IG8keepFactory(msg.sender).g8keepTokenVesting();
_balances[g8keepVester] = tokensToDeployer;
emit Transfer(address(0), g8keepVester, tokensToDeployer);
IG8keepDeployerVesting(g8keepVester).deploymentVest(_deployer, tokensToDeployer, _deployVestTime);
}
}
}
function maxSnipeProtectionBuyWithoutPenalty() external view returns (uint256 _amount) {
_amount = _balances[UNISWAP_V2_PAIR];
if (block.timestamp < SNIPE_PROTECTION_END) {
(,,uint256 cachedThirdPartyLPAmount) = _checkLPForIncreaseView();
if (cachedThirdPartyLPAmount > 0) {
if (cachedThirdPartyLPAmount > _amount) {
_amount = 0;
} else {
unchecked {
_amount = _amount - cachedThirdPartyLPAmount;
}
}
}
uint256 elapsedSeconds = block.timestamp - GENESIS_TIME;
uint256 cachedLPBalanceBaseline = lpBalanceBaseline;
uint256 expectedBalance1 =
cachedLPBalanceBaseline - cachedLPBalanceBaseline * elapsedSeconds / SNIPE_PROTECTION_SECONDS;
if (_amount < expectedBalance1) {
_amount = 0;
} else {
_amount = _amount - expectedBalance1;
}
}
}
function expectedAmount1Out(uint256 amount0In) external view returns (uint256 amount1Out, uint256 penaltyAmount1Out, uint256 feesAmount1Out) {
(uint256 reserve0, uint256 reserve1, uint256 cachedThirdPartyLPAmount) = _checkLPForIncreaseView();
amount1Out = _getAmountOut(amount0In, reserve0, reserve1);
if (block.timestamp < SNIPE_PROTECTION_END) {
(amount1Out, penaltyAmount1Out) = _adjustAmountOut(amount1Out, cachedThirdPartyLPAmount, lpBalanceBaseline);
}
unchecked {
uint256 deployerFee = buyFee;
if (deployerFee > 0) {
feesAmount1Out += (amount1Out * deployerFee) / BPS;
}
if (G8KEEP_FEE > 0) {
feesAmount1Out += (amount1Out * G8KEEP_FEE) / BPS;
}
amount1Out = amount1Out - feesAmount1Out;
}
}
function balanceOf(address account) public view returns (uint256 _balance) {
_balance = _balances[account];
}
function allowance(address owner, address spender) public view returns (uint256 _allowance) {
_allowance = _allowances[owner][spender];
}
function approve(address spender, uint256 amount) external returns (bool) {
_approve(msg.sender, spender, amount);
return true;
}
function transfer(address recipient, uint256 amount) external returns (bool) {
_transfer(msg.sender, recipient, amount);
return true;
}
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool) {
uint256 currentAllowance = _allowances[sender][msg.sender];
if (currentAllowance != type(uint256).max) {
if (currentAllowance < amount) revert InsufficientAllowance();
unchecked {
_approve(sender, msg.sender, currentAllowance - amount);
}
}
_transfer(sender, recipient, amount);
return true;
}
function updateTreasuryWallet(address newAddress) external onlyOwner {
if (newAddress == address(0) || newAddress == UNISWAP_V2_PAIR) {
revert InvalidTreasuryAddress();
}
treasuryWallet = newAddress;
emit TreasuryWalletUpdated(newAddress);
}
function updateFees(uint16 _buyFee, uint16 _sellFee) external onlyOwner {
uint16 _oldBuyFee = buyFee;
uint16 _oldSellfee = sellFee;
if (_oldBuyFee < _buyFee || _oldSellfee < _sellFee) {
revert CannotIncreaseFees();
}
buyFee = _buyFee;
sellFee = _sellFee;
emit DeployerFeesUpdated(_buyFee, _sellFee);
}
function withdrawToken(address tokenAddress, address to) external onlyOwner {
uint256 _contractBalance = IERC20(tokenAddress).balanceOf(address(this));
SafeTransferLib.safeTransfer(tokenAddress, to, _contractBalance);
}
function withdrawToken(address tokenAddress, address to, uint256 amount) external onlyOwner {
SafeTransferLib.safeTransfer(tokenAddress, to, amount);
}
function _approve(address owner, address spender, uint256 amount) private {
if (owner == address(0)) revert ZeroAddress();
if (spender == address(0)) revert ZeroAddress();
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _transfer(address from, address to, uint256 amount) private {
if (from == address(0)) revert ZeroAddress();
if (to == address(0)) revert ZeroAddress();
amount = _applySnipeProtection(from, to, amount);
uint256 senderBalance = _balances[from];
if (senderBalance < amount) revert InsufficientBalance();
unchecked {
_balances[from] = senderBalance - amount;
}
uint256 toAmount = amount;
if (from != G8KEEP) {
if (to == UNISWAP_V2_PAIR) {
toAmount = _applyFees(from, amount, sellFee);
} else if (from == UNISWAP_V2_PAIR) {
toAmount = _applyFees(from, amount, buyFee);
}
}
unchecked {
_balances[to] += toAmount;
emit Transfer(from, to, toAmount);
}
}
function _applyFees(
address from,
uint256 amount,
uint256 deployerFee
) internal returns (uint256 toAmount) {
unchecked {
uint256 deployerFees;
if (deployerFee > 0) {
deployerFees = (amount * deployerFee) / BPS;
address _treasuryWallet = treasuryWallet;
_balances[_treasuryWallet] += deployerFees;
emit Transfer(from, _treasuryWallet, deployerFees);
}
uint256 g8keepFees;
if (G8KEEP_FEE > 0) {
g8keepFees = (amount * G8KEEP_FEE) / BPS;
_balances[G8KEEP] += g8keepFees;
emit Transfer(from, G8KEEP, g8keepFees);
}
toAmount = amount - deployerFees - g8keepFees;
}
}
function _applySnipeProtection(
address from,
address to,
uint256 amount1Out
) internal returns (uint256 adjustedAmount1Out) {
adjustedAmount1Out = amount1Out;
if (block.timestamp < SNIPE_PROTECTION_END) {
(uint256 reserve0, uint256 reserve1, uint256 cachedThirdPartyLPAmount) = _checkLPForIncrease();
if (from == UNISWAP_V2_PAIR) {
if (to == UNISWAP_V2_PAIR) {
revert CannotTransferFromAndToUniswapV2Pair();
}
if (amount1Out == 0) return 0;
uint256 balance0 = IERC20(PAIRED_TOKEN).balanceOf(UNISWAP_V2_PAIR);
if (balance0 < reserve0) {
revert InsufficientPoolInput();
}
uint256 amount0In;
unchecked {
amount0In = balance0 - reserve0;
}
uint256 maxAmount1Out = _getAmountOut(amount0In, reserve0, reserve1);
if (amount1Out > maxAmount1Out) {
revert ExcessiveAmountOut();
}
uint256 penaltyAmount1Out;
uint256 cachedLPBalanceBaseline = lpBalanceBaseline;
(adjustedAmount1Out, penaltyAmount1Out) = _adjustAmountOut(amount1Out, cachedThirdPartyLPAmount, cachedLPBalanceBaseline);
if (penaltyAmount1Out > 0) {
lpBalanceBaseline = cachedLPBalanceBaseline - penaltyAmount1Out;
_balances[from] -= penaltyAmount1Out;
_balances[PENALTY_TAX_RECEIVER] += penaltyAmount1Out;
emit Transfer(from, PENALTY_TAX_RECEIVER, penaltyAmount1Out);
}
}
}
}
function _checkLPForIncrease() internal returns (uint256 reserve0, uint256 reserve1, uint256 cachedThirdPartyLPAmount) {
(reserve0, reserve1) = _getTokenReserves();
cachedThirdPartyLPAmount = thirdPartyLPAmount;
uint256 _cachedLPReserve1 = cachedLPReserve1;
cachedLPReserve1 = uint112(reserve1);
uint256 _lpTotalSupply = IERC20(UNISWAP_V2_PAIR).totalSupply();
uint256 _lastLPTotalSupply = lastLPTotalSupply;
if (_lpTotalSupply != _lastLPTotalSupply) {
if (_lpTotalSupply < _lastLPTotalSupply) {
revert CannotBurnLiquidityDuringSnipeProtection();
}
lastLPTotalSupply = _lpTotalSupply;
if (_lastLPTotalSupply != 0) {
if (reserve1 > _cachedLPReserve1) {
unchecked {
cachedThirdPartyLPAmount = cachedThirdPartyLPAmount +
(_lpTotalSupply - _lastLPTotalSupply) *
_cachedLPReserve1 / _lastLPTotalSupply;
thirdPartyLPAmount = uint112(cachedThirdPartyLPAmount);
}
}
}
}
}
function _checkLPForIncreaseView() internal view returns (uint256 reserve0, uint256 reserve1, uint256 cachedThirdPartyLPAmount) {
cachedThirdPartyLPAmount = thirdPartyLPAmount;
(reserve0,reserve1) = _getTokenReserves();
uint256 _lpTotalSupply = IERC20(UNISWAP_V2_PAIR).totalSupply();
if (!(_lpTotalSupply == lastLPTotalSupply || lastLPTotalSupply == 0)) {
uint256 _cachedLPReserve1 = cachedLPReserve1;
if (reserve1 > _cachedLPReserve1) {
unchecked {
cachedThirdPartyLPAmount = cachedThirdPartyLPAmount + reserve1 - _cachedLPReserve1;
}
}
}
}
function _adjustAmountOut(
uint256 amount1Out,
uint256 cachedThirdPartyLPAmount,
uint256 cachedLPBalanceBaseline
) internal view returns (uint256 adjustedAmount1Out, uint256 penaltyAmount1Out) {
uint256 balance1 = _balances[UNISWAP_V2_PAIR];
if (amount1Out > balance1) {
revert InsufficientBalance();
}
adjustedAmount1Out = amount1Out;
uint256 adjustedBalance1;
unchecked {
adjustedBalance1 = balance1 - adjustedAmount1Out;
}
if (cachedThirdPartyLPAmount > 0) {
if (cachedThirdPartyLPAmount > adjustedBalance1) {
adjustedBalance1 = 0;
} else {
unchecked {
adjustedBalance1 = adjustedBalance1 - cachedThirdPartyLPAmount;
}
}
}
uint256 elapsedSeconds = block.timestamp - GENESIS_TIME;
uint256 expectedBalance1 =
cachedLPBalanceBaseline - cachedLPBalanceBaseline * elapsedSeconds / SNIPE_PROTECTION_SECONDS;
if (expectedBalance1 > adjustedBalance1) {
uint256 exponentPenalty = SNIPE_PENALTY_BASE_EXPONENT;
if (elapsedSeconds < SNIPE_PROTECTION_HEAVY_PENALTY_SECONDS) {
unchecked {
exponentPenalty +=
SNIPE_PROTECTION_HEAVY_EXPONENT_START *
(SNIPE_PROTECTION_HEAVY_PENALTY_SECONDS - elapsedSeconds) /
SNIPE_PROTECTION_HEAVY_PENALTY_SECONDS;
}
}
for (uint256 i; i < exponentPenalty; ++i) {
adjustedAmount1Out =
adjustedAmount1Out * adjustedBalance1 / expectedBalance1;
}
unchecked {
penaltyAmount1Out = amount1Out - adjustedAmount1Out;
}
}
}
function _getTokenReserves() internal view returns (uint256 reserve0, uint256 reserve1) {
(reserve0,reserve1,) = IUniswapV2Pair(UNISWAP_V2_PAIR).getReserves();
}
function _getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) internal pure returns (uint256 amountOut) {
if (reserveIn == 0 || reserveOut == 0) revert InvalidReserves();
uint256 amountInWithFee = amountIn * 997;
uint256 numerator = amountInWithFee * reserveOut;
uint256 denominator = reserveIn * 1000 + amountInWithFee;
amountOut = numerator / denominator;
}
}
