文件 1 的 1：MintStakeShareExpansion.sol
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
pragma solidity ^0.8.20;
abstract contract Ownable is Context {
address private _owner;
error OwnableUnauthorizedAccount(address account);
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
pragma solidity ^0.8.20;
interface IERC20Errors {
error ERC20InsufficientBalance(
address sender,
uint256 balance,
uint256 needed
);
error ERC20InvalidSender(address sender);
error ERC20InvalidReceiver(address receiver);
error ERC20InsufficientAllowance(
address spender,
uint256 allowance,
uint256 needed
);
error ERC20InvalidApprover(address approver);
error ERC20InvalidSpender(address spender);
}
interface IERC721Errors {
error ERC721InvalidOwner(address owner);
error ERC721NonexistentToken(uint256 tokenId);
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
error ERC721InvalidSender(address sender);
error ERC721InvalidReceiver(address receiver);
error ERC721InsufficientApproval(address operator, uint256 tokenId);
error ERC721InvalidApprover(address approver);
error ERC721InvalidOperator(address operator);
}
interface IERC1155Errors {
error ERC1155InsufficientBalance(
address sender,
uint256 balance,
uint256 needed,
uint256 tokenId
);
error ERC1155InvalidSender(address sender);
error ERC1155InvalidReceiver(address receiver);
error ERC1155MissingApprovalForAll(address operator, address owner);
error ERC1155InvalidApprover(address approver);
error ERC1155InvalidOperator(address operator);
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}
pragma solidity ^0.8.20;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 value) external returns (bool);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
}
pragma solidity ^0.8.20;
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity ^0.8.20;
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => uint256))
private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return 18;
}
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
function allowance(
address owner,
address spender
) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
function approve(
address spender,
uint256 value
) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
function transferFrom(
address from,
address to,
uint256 value
) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
function _update(address from, address to, uint256 value) internal virtual {
if (from == address(0)) {
_totalSupply += value;
} else {
uint256 fromBalance = _balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
_balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
_totalSupply -= value;
}
} else {
unchecked {
_balances[to] += value;
}
}
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
function _approve(
address owner,
address spender,
uint256 value,
bool emitEvent
) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
function _spendAllowance(
address owner,
address spender,
uint256 value
) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(
spender,
currentAllowance,
value
);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}
pragma solidity ^0.8.20;
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 value) public virtual {
_burn(_msgSender(), value);
}
function burnFrom(address account, uint256 value) public virtual {
_spendAllowance(account, _msgSender(), value);
_burn(account, value);
}
}
pragma solidity ^0.8.20;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
pragma solidity ^0.8.20;
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS
}
error ECDSAInvalidSignature();
error ECDSAInvalidSignatureLength(uint256 length);
error ECDSAInvalidSignatureS(bytes32 s);
function tryRecover(
bytes32 hash,
bytes memory signature
) internal pure returns (address, RecoverError, bytes32) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (
address(0),
RecoverError.InvalidSignatureLength,
bytes32(signature.length)
);
}
}
function recover(
bytes32 hash,
bytes memory signature
) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(
hash,
signature
);
_throwError(error, errorArg);
return recovered;
}
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError, bytes32) {
unchecked {
bytes32 s = vs &
bytes32(
0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff
);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
}
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(
hash,
r,
vs
);
_throwError(error, errorArg);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError, bytes32) {
if (
uint256(s) >
0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0
) {
return (address(0), RecoverError.InvalidSignatureS, s);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature, bytes32(0));
}
return (signer, RecoverError.NoError, bytes32(0));
}
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
(address recovered, RecoverError error, bytes32 errorArg) = tryRecover(
hash,
v,
r,
s
);
_throwError(error, errorArg);
return recovered;
}
function _throwError(RecoverError error, bytes32 errorArg) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert ECDSAInvalidSignature();
} else if (error == RecoverError.InvalidSignatureLength) {
revert ECDSAInvalidSignatureLength(uint256(errorArg));
} else if (error == RecoverError.InvalidSignatureS) {
revert ECDSAInvalidSignatureS(errorArg);
}
}
}
pragma solidity ^0.8.20;
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
pragma solidity ^0.8.20;
library Math {
error MathOverflowedMulDiv();
enum Rounding {
Floor,
Ceil,
Trunc,
Expand
}
function tryAdd(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
if (b == 0) {
return a / b;
}
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0 = x * y;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
if (denominator <= prod1) {
revert MathOverflowedMulDiv();
}
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (0 - denominator);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(
uint256 a,
Rounding rounding
) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return
result +
(unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(
uint256 value,
Rounding rounding
) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return
result +
(unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10 ** 64) {
value /= 10 ** 64;
result += 64;
}
if (value >= 10 ** 32) {
value /= 10 ** 32;
result += 32;
}
if (value >= 10 ** 16) {
value /= 10 ** 16;
result += 16;
}
if (value >= 10 ** 8) {
value /= 10 ** 8;
result += 8;
}
if (value >= 10 ** 4) {
value /= 10 ** 4;
result += 4;
}
if (value >= 10 ** 2) {
value /= 10 ** 2;
result += 2;
}
if (value >= 10 ** 1) {
result += 1;
}
}
return result;
}
function log10(
uint256 value,
Rounding rounding
) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return
result +
(unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(
uint256 value,
Rounding rounding
) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return
result +
(
unsignedRoundsUp(rounding) && 1 << (result << 3) < value
? 1
: 0
);
}
}
function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
return uint8(rounding) % 2 == 1;
}
}
pragma solidity ^0.8.20;
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
pragma solidity ^0.8.20;
library Strings {
bytes16 private constant HEX_DIGITS = "0123456789abcdef";
uint8 private constant ADDRESS_LENGTH = 20;
error StringsInsufficientHexLength(uint256 value, uint256 length);
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), HEX_DIGITS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toStringSigned(
int256 value
) internal pure returns (string memory) {
return
string.concat(
value < 0 ? "-" : "",
toString(SignedMath.abs(value))
);
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(
uint256 value,
uint256 length
) internal pure returns (string memory) {
uint256 localValue = value;
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = HEX_DIGITS[localValue & 0xf];
localValue >>= 4;
}
if (localValue != 0) {
revert StringsInsufficientHexLength(value, length);
}
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), ADDRESS_LENGTH);
}
function equal(
string memory a,
string memory b
) internal pure returns (bool) {
return
bytes(a).length == bytes(b).length &&
keccak256(bytes(a)) == keccak256(bytes(b));
}
}
pragma solidity ^0.8.20;
library MessageHashUtils {
function toEthSignedMessageHash(
bytes32 messageHash
) internal pure returns (bytes32 digest) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, messageHash)
digest := keccak256(0x00, 0x3c)
}
}
function toEthSignedMessageHash(
bytes memory message
) internal pure returns (bytes32) {
return
keccak256(
bytes.concat(
"\x19Ethereum Signed Message:\n",
bytes(Strings.toString(message.length)),
message
)
);
}
function toDataWithIntendedValidatorHash(
address validator,
bytes memory data
) internal pure returns (bytes32) {
return keccak256(abi.encodePacked(hex"19_00", validator, data));
}
function toTypedDataHash(
bytes32 domainSeparator,
bytes32 structHash
) internal pure returns (bytes32 digest) {
assembly {
let ptr := mload(0x40)
mstore(ptr, hex"19_01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
digest := keccak256(ptr, 0x42)
}
}
}
pragma solidity ^0.8.20;
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
function getAddressSlot(
bytes32 slot
) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(
bytes32 slot
) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(
bytes32 slot
) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(
bytes32 slot
) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(
bytes32 slot
) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(
string storage store
) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(
bytes32 slot
) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(
bytes storage store
) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
pragma solidity ^0.8.20;
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant FALLBACK_SENTINEL =
0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(
string memory str
) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(
string memory value,
string storage store
) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(FALLBACK_SENTINEL);
}
}
function toStringWithFallback(
ShortString value,
string storage store
) internal pure returns (string memory) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(
ShortString value,
string storage store
) internal view returns (uint256) {
if (ShortString.unwrap(value) != FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
pragma solidity ^0.8.20;
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant TYPE_HASH =
keccak256(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
);
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return
keccak256(
abi.encode(
TYPE_HASH,
_hashedName,
_hashedVersion,
block.chainid,
address(this)
)
);
}
function _hashTypedDataV4(
bytes32 structHash
) internal view virtual returns (bytes32) {
return
MessageHashUtils.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f",
_EIP712Name(),
_EIP712Version(),
block.chainid,
address(this),
bytes32(0),
new uint256[](0)
);
}
function _EIP712Name() internal view returns (string memory) {
return _name.toStringWithFallback(_nameFallback);
}
function _EIP712Version() internal view returns (string memory) {
return _version.toStringWithFallback(_versionFallback);
}
}
pragma solidity ^0.8.20;
abstract contract Nonces {
error InvalidAccountNonce(address account, uint256 currentNonce);
mapping(address account => uint256) private _nonces;
function nonces(address owner) public view virtual returns (uint256) {
return _nonces[owner];
}
function _useNonce(address owner) internal virtual returns (uint256) {
unchecked {
return _nonces[owner]++;
}
}
function _useCheckedNonce(address owner, uint256 nonce) internal virtual {
uint256 current = _useNonce(owner);
if (nonce != current) {
revert InvalidAccountNonce(owner, current);
}
}
}
pragma solidity ^0.8.20;
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712, Nonces {
bytes32 private constant PERMIT_TYPEHASH =
keccak256(
"Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
);
error ERC2612ExpiredSignature(uint256 deadline);
error ERC2612InvalidSigner(address signer, address owner);
constructor(string memory name) EIP712(name, "1") {}
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual {
if (block.timestamp > deadline) {
revert ERC2612ExpiredSignature(deadline);
}
bytes32 structHash = keccak256(
abi.encode(
PERMIT_TYPEHASH,
owner,
spender,
value,
_useNonce(owner),
deadline
)
);
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
if (signer != owner) {
revert ERC2612InvalidSigner(signer, owner);
}
_approve(owner, spender, value);
}
function nonces(
address owner
) public view virtual override(IERC20Permit, Nonces) returns (uint256) {
return super.nonces(owner);
}
function DOMAIN_SEPARATOR() external view virtual returns (bytes32) {
return _domainSeparatorV4();
}
}
pragma solidity ^0.8.9;
interface IWETH is IERC20 {
function deposit() external payable;
function withdraw(uint256 wad) external;
}
pragma solidity ^0.8.20;
abstract contract ReentrancyGuard {
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
uint256 private _status;
error ReentrancyGuardReentrantCall();
constructor() {
_status = NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
if (_status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
_status = ENTERED;
}
function _nonReentrantAfter() private {
_status = NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == ENTERED;
}
}
pragma solidity ^0.8.0;
interface IDexFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
pragma solidity ^0.8.0;
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(
address owner,
address spender
) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(
address from,
address to,
uint value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint);
function permit(
address owner,
address spender,
uint value,
uint deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(
address indexed sender,
uint amount0,
uint amount1,
address indexed to
);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(
uint amount0Out,
uint amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
pragma solidity ^0.8.0;
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETH(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountToken, uint256 amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint256 liquidity,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountA, uint256 amountB);
function removeLiquidityETHWithPermit(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountToken, uint256 amountETH);
function swapExactTokensForTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapTokensForExactTokens(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactETHForTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function swapTokensForExactETH(
uint256 amountOut,
uint256 amountInMax,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapExactTokensForETH(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external returns (uint256[] memory amounts);
function swapETHForExactTokens(
uint256 amountOut,
address[] calldata path,
address to,
uint256 deadline
) external payable returns (uint256[] memory amounts);
function quote(
uint256 amountA,
uint256 reserveA,
uint256 reserveB
) external pure returns (uint256 amountB);
function getAmountOut(
uint256 amountIn,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountOut);
function getAmountIn(
uint256 amountOut,
uint256 reserveIn,
uint256 reserveOut
) external pure returns (uint256 amountIn);
function getAmountsOut(
uint256 amountIn,
address[] calldata path
) external view returns (uint256[] memory amounts);
function getAmountsIn(
uint256 amountOut,
address[] calldata path
) external view returns (uint256[] memory amounts);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
) external returns (uint256 amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint256 liquidity,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline,
bool approveMax,
uint8 v,
bytes32 r,
bytes32 s
) external returns (uint256 amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
pragma solidity ^0.8.20;
contract MintStakeShareExpansion is
ERC20,
ERC20Burnable,
Ownable,
ERC20Permit,
ReentrancyGuard
{
struct TokenDetails {
uint256 ethRaised;
uint256 initialPrice;
uint256 priceSupplyInterval;
uint256 priceIncreasePercent;
uint256 currentPrice;
uint256 uniswapPrice;
uint256 totalSupply;
uint256 currentPriceTier;
}
uint256 private totalEthRaised;
uint256 private initialPrice;
uint256 private priceSupplyInterval;
uint256 private priceIncreasePercent;
mapping(address => address) public referrers;
mapping(address => uint256) public referralEarnings;
uint256 public totalReferrals;
uint256 public referrerReward = 5;
uint256 public maxReferralLevels = 3;
uint256 public tierReductionRate = 50;
IUniswapV2Router02 public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address public operationsAddress;
IWETH private immutable WETH;
address public stakingAddress;
address public tokenManager;
uint256 public tradingActiveBlock = 0;
mapping(address => bool) public bot;
uint256 public botsCaught;
bool public tradingActive = false;
bool public swapEnabled = false;
uint256 public buyTotalFees;
uint256 public sellTotalFees;
uint256 public percentOfMintForLiquidity;
uint256 private latestPriceTier;
mapping(address => bool) private _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
event EnabledTrading();
event ExcludeFromFees(address indexed account, bool isExcluded);
event AddLiquidity(
uint256 tokensAdded,
uint256 ethAdded,
uint256 liquidityTokens
);
event Purchase(
address indexed beneficiary,
uint256 contribution,
uint256 amount
);
event Referral(
address indexed beneficiary,
address indexed user,
uint256 amount
);
constructor(
string memory _name,
string memory _symbol,
uint256 _priceSupplyInterval,
uint256 _priceIncreasePercent,
address _uniswapV2Router
)
ERC20(_name, _symbol)
ERC20Permit(_name)
Ownable(msg.sender)
ReentrancyGuard()
{
address newOwner = msg.sender;
priceSupplyInterval = _priceSupplyInterval;
priceIncreasePercent = 100 / _priceIncreasePercent;
dexRouter = IUniswapV2Router02(_uniswapV2Router);
WETH = IWETH(dexRouter.WETH());
lpPair = IDexFactory(dexRouter.factory()).createPair(
address(this),
address(WETH)
);
_setAutomatedMarketMakerPair(address(lpPair), true);
swapTokensAtAmount = (priceSupplyInterval / 100);
buyTotalFees = 4;
sellTotalFees = 12;
percentOfMintForLiquidity = 75;
excludeFromFees(newOwner, true);
excludeFromFees(address(0), true);
excludeFromFees(address(this), true);
excludeFromFees(address(0xdead), true);
operationsAddress = newOwner;
}
function tokenDetails() external view returns (TokenDetails memory) {
return
TokenDetails({
ethRaised: totalEthRaised,
initialPrice: initialPrice,
priceSupplyInterval: priceSupplyInterval,
priceIncreasePercent: priceIncreasePercent,
currentPrice: calculatePrice(),
uniswapPrice: _getUniswapPrice(),
totalSupply: totalSupply(),
currentPriceTier: currentPriceTier()
});
}
function calculatePrice() public view returns (uint256) {
uint256 currentTier = currentPriceTier();
if (currentTier == 0) {
return initialPrice;
} else {
return _calculatePrice(currentTier);
}
}
function setAutomatedMarketMakerPair(
address pair,
bool value
) external onlyOwner {
require(
pair != lpPair,
"The pair cannot be removed from automatedMarketMakerPairs"
);
_setAutomatedMarketMakerPair(pair, value);
}
function calculatePriceByTier(
uint _priceTier
) public view returns (uint256) {
if (_priceTier == 0) {
return initialPrice;
} else {
return _calculatePrice(_priceTier);
}
}
receive() external payable {}
function currentPriceTier() public view returns (uint256) {
uint256 calculated = (totalSupply() / priceSupplyInterval);
return calculated >= latestPriceTier ? calculated : latestPriceTier;
}
function setInitialPrice(uint256 _initialPrice) external onlyOwner {
require(
currentPriceTier() == 0,
"Initial price can only be set in first price tier"
);
initialPrice = ((1e18 * 1e18) / (_initialPrice));
}
function enableTrading() external onlyOwner {
require(initialPrice > 0, "Initial price must be set");
require(!tradingActive, "Cannot reenable trading");
tradingActive = true;
swapEnabled = true;
tradingActiveBlock = block.number;
uint ethBalance = address(this).balance;
_mintAndAddLiquidityWithETH(ethBalance);
emit EnabledTrading();
}
function _updatePriceTier() internal {
uint256 calculated = (totalSupply() / priceSupplyInterval);
if (calculated > latestPriceTier) {
latestPriceTier = calculated;
}
}
function mint(address account, uint256 value) external {
if (msg.sender != tokenManager && msg.sender != stakingAddress) {
revert("Only token manager and staking contract can mint");
}
_mint(account, value);
}
function buyWithMint(
address beneficiary,
address _referrer
) external payable nonReentrant {
require(initialPrice > 0, "Initial price must be set");
uint amount = msg.value;
totalEthRaised += amount;
uint256 tokens = getTokenMintAmount(amount);
_mint(beneficiary, tokens);
_setReferrer(_referrer);
_handleReferralETH(amount);
_handleIncomingETHFromMint();
_updatePriceTier();
emit Purchase(beneficiary, amount, tokens);
}
function setReferrer(address referrer) external {
require(_setReferrer(referrer), "Setting referrer failed.");
}
function _setReferrer(address referrer) internal returns (bool) {
if (
referrers[msg.sender] != address(0) ||
referrer == address(0) ||
referrer == msg.sender ||
_isContract(referrer)
) {
return false;
}
referrers[msg.sender] = referrer;
return true;
}
function _handleReferralETH(uint256 amount) internal {
uint maxLevels = maxReferralLevels;
address thisReferrer = msg.sender;
uint256 referralAmount = (amount * referrerReward) / 100;
for (uint i = 0; i < maxLevels; i++) {
thisReferrer = referrers[thisReferrer];
if (thisReferrer == address(0)) {
break;
}
if (!_isContract(thisReferrer)) {
payable(thisReferrer).transfer(referralAmount);
referralEarnings[thisReferrer] += referralAmount;
totalReferrals += referralAmount;
}
emit Referral(thisReferrer, msg.sender, referralAmount);
referralAmount =
referralAmount -
(referralAmount * tierReductionRate) /
100;
}
}
function _handleIncomingETHFromMint() internal {
uint amount = address(this).balance;
if (tradingActive) {
uint ethForLiq;
if ((calculatePrice() * 2) < _getUniswapPrice()) {
ethForLiq = amount / 5;
} else {
ethForLiq = (amount * percentOfMintForLiquidity) / 100;
}
_mintAndAddLiquidityWithETH(ethForLiq);
bool success;
(success, ) = address(operationsAddress).call{
value: address(this).balance
}("");
}
}
function getTokenMintAmount(
uint256 _inputAmount
) public view returns (uint256) {
uint256 price = calculatePrice();
uint256 outputTokens = (_inputAmount / price) * 10 ** 18;
if (outputTokens > priceSupplyInterval) {
uint priceTotalSupply = totalSupply() + outputTokens;
uint higherPriceTier = (priceTotalSupply / priceSupplyInterval);
price = _calculatePrice(higherPriceTier);
outputTokens = (_inputAmount / price) * 10 ** 18;
}
return outputTokens;
}
function fracExp(
uint k,
uint q,
uint n,
uint p
) private pure returns (uint) {
uint s = 0;
uint N = 1;
uint B = 1;
for (uint i = 0; i < p; ++i) {
unchecked {
s += (k * N) / B / (q ** i);
N = N * (n - i);
B = B * (i + 1);
}
}
return s;
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function updateFees(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
sellTotalFees = _sellFee;
buyTotalFees = _buyFee;
require(sellTotalFees <= 25, "Must keep sell fees at 25% or less");
require(buyTotalFees <= 10, "Must keep buy fees at 10% or less");
}
function updateReferrals(
uint256 _referralFee,
uint256 _maxReferralLevels,
uint256 _tierReductionPercent
) external onlyOwner {
referrerReward = _referralFee;
maxReferralLevels = _maxReferralLevels;
tierReductionRate = _tierReductionPercent;
require(
tierReductionRate <= 50,
"Must keep tier reduction at 50% or less"
);
require(referrerReward <= 10, "Must keep referral fee at 10% or less");
require(maxReferralLevels <= 10, "Must keep levels at 10 or less");
}
function transferForeignToken(
address _token,
address _to
) external onlyOwner returns (bool _sent) {
require(_token != address(0), "_token address cannot be 0");
uint256 _contractBalance = IERC20(_token).balanceOf(address(this));
_sent = IERC20(_token).transfer(_to, _contractBalance);
}
function withdrawStuckETH() external onlyOwner {
bool success;
(success, ) = address(msg.sender).call{ value: address(this).balance }(
""
);
}
function setTokenManager(address _tokenManager) external onlyOwner {
require(
_tokenManager != address(0),
"_tokenManager address cannot be 0"
);
_isExcludedFromFees[_tokenManager] = true;
tokenManager = _tokenManager;
}
function setStakingAddress(address _stakingAddress) external onlyOwner {
require(
_stakingAddress != address(0),
"_stakingAddress address cannot be 0"
);
require(
_isContract(_stakingAddress),
"_stakingAddress must be a contract"
);
stakingAddress = _stakingAddress;
}
function setOperationsAddress(
address _operationsAddress
) external onlyOwner {
require(
_operationsAddress != address(0),
"_operationsAddress address cannot be 0"
);
operationsAddress = payable(_operationsAddress);
}
function _mintAndAddLiquidityWithETH(
uint256 ethAmount
) private returns (uint256 liquidity) {
require(address(this).balance >= ethAmount, "Insufficient ETH balance");
IWETH(WETH).deposit{ value: ethAmount }();
(uint res0, uint res1, ) = IUniswapV2Pair(lpPair).getReserves();
uint tokens;
if (res0 > 0 && res1 > 0) {
tokens = _getLiquidityAmount(ethAmount, res0, res1);
} else {
tokens = getTokenMintAmount(ethAmount);
}
assert(IWETH(WETH).transfer(lpPair, ethAmount));
_mint(lpPair, tokens);
liquidity = IUniswapV2Pair(lpPair).mint(address(0xdead));
emit AddLiquidity(tokens, ethAmount, liquidity);
}
function _getAmountOut(
uint amountIn,
uint reserveIn,
uint reserveOut
) internal pure returns (uint amountOut) {
require(amountIn > 0, "INSUFFICIENT_INPUT_AMOUNT");
require(reserveIn > 0 && reserveOut > 0, "INSUFFICIENT_LIQUIDITY");
uint amountInWithFee = amountIn * 997;
uint numerator = amountInWithFee * reserveOut;
uint denominator = (reserveIn * 1000) + amountInWithFee;
amountOut = numerator / denominator;
}
function _buyAndBurn(uint256 amount) private {
(, uint amountOut0, uint amountOut1) = _getSwapAmounts(amount);
IWETH(WETH).deposit{ value: amount }();
IWETH(WETH).transfer(lpPair, amount);
IUniswapV2Pair(lpPair).swap(
amountOut0,
amountOut1,
address(0xdead),
new bytes(0)
);
}
function _getLiquidityAmount(
uint amountIn,
uint reserveIn,
uint reserveOut
) internal pure returns (uint amountOut) {
require(amountIn > 0, "INSUFFICIENT_INPUT_AMOUNT");
require(reserveIn > 0 && reserveOut > 0, "INSUFFICIENT_LIQUIDITY");
uint numerator = reserveOut;
uint denominator = (reserveIn);
amountOut = (numerator / denominator) * amountIn;
}
function _getSwapAmounts(
uint256 _amount
) private view returns (uint amountOut, uint amountOut0, uint amountOut1) {
(uint reserve0, uint reserve1, ) = IUniswapV2Pair(lpPair).getReserves();
(uint reserveA, uint reserveB) = IUniswapV2Pair(lpPair).token0() ==
address(WETH)
? (reserve0, reserve1)
: (reserve1, reserve0);
amountOut = _getAmountOut(_amount, reserveA, reserveB);
(amountOut0, amountOut1) = IUniswapV2Pair(lpPair).token0() ==
address(WETH)
? (uint(0), amountOut)
: (amountOut, uint(0));
}
function _calculatePrice(uint priceTier) private view returns (uint) {
return fracExp(initialPrice, priceIncreasePercent, priceTier, 5);
}
function _isContract(address _addr) private view returns (bool) {
uint32 size;
assembly {
size := extcodesize(_addr)
}
return (size > 0);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
automatedMarketMakerPairs[pair] = value;
}
function airdropToWallets(
address[] memory wallets,
uint256[] memory amountsInTokens
) external onlyOwner {
require(
wallets.length == amountsInTokens.length,
"arrays must be the same length"
);
require(
wallets.length < 600,
"Can only airdrop 600 wallets per txn due to gas limits"
);
for (uint256 i = 0; i < wallets.length; i++) {
address wallet = wallets[i];
uint256 amount = amountsInTokens[i];
super._transfer(msg.sender, wallet, amount);
}
}
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
require(
newAmount >= (totalSupply() * 1) / 100000,
"Swap amount cannot be lower than 0.001% total supply."
);
require(
newAmount <= (totalSupply() * 1) / 1000,
"Swap amount cannot be higher than 0.1% total supply."
);
swapTokensAtAmount = newAmount;
}
function _update(
address from,
address to,
uint256 amount
) internal override {
if (!tradingActive && from != address(0)) {
require(
_isExcludedFromFees[from] || _isExcludedFromFees[to],
"Trading is not active."
);
}
require(!bot[from] && !bot[to], "Bots cannot transfer tokens.");
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if (
canSwap &&
swapEnabled &&
!swapping &&
!automatedMarketMakerPairs[from] &&
!_isExcludedFromFees[from] &&
!_isExcludedFromFees[to]
) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
if (
_isExcludedFromFees[from] ||
_isExcludedFromFees[to] ||
from == address(0)
) {
takeFee = false;
}
uint256 fees = 0;
if (takeFee) {
if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
fees = (amount * sellTotalFees) / 100;
}
else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = (amount * buyTotalFees) / 100;
}
if (fees > 0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._update(from, to, amount);
}
function swapEthForTokens(uint256 _ethAmount, address _recipient) private {
address[] memory path = new address[](2);
path[0] = address(WETH);
path[1] = address(this);
dexRouter.swapExactETHForTokensSupportingFeeOnTransferTokens{
value: _ethAmount
}(
0,
path,
_recipient,
block.timestamp
);
}
function swapTokensForEth(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = dexRouter.WETH();
_approve(address(this), address(dexRouter), tokenAmount);
dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp
);
}
function swapBack() private {
uint256 contractBalance = balanceOf(address(this));
if (contractBalance == 0) {
return;
}
bool success;
uint256 liquidityTokens = (contractBalance) / 3;
uint256 ethBalance = address(this).balance;
swapTokensForEth(contractBalance - liquidityTokens);
ethBalance = address(this).balance - ethBalance;
uint256 ethForLiquidity = ethBalance;
uint256 ethForOperations = (ethBalance) / 2;
ethForLiquidity -= ethForOperations;
if (liquidityTokens > 0 && ethForLiquidity > 0) {
addLiquidity(liquidityTokens, ethForLiquidity);
}
if (address(this).balance > 0) {
(success, ) = address(operationsAddress).call{
value: address(this).balance
}("");
}
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
_approve(address(this), address(dexRouter), tokenAmount);
dexRouter.addLiquidityETH{ value: ethAmount }(
address(this),
tokenAmount,
0,
0,
address(0xdead),
block.timestamp
);
}
function forceSwapBack() external onlyOwner {
require(balanceOf(address(this)) >= 0, "No tokens to swap");
swapping = true;
swapBack();
swapping = false;
}
function _getUniswapPrice() private view returns (uint256) {
(uint256 reserve0, uint256 reserve1, ) = IUniswapV2Pair(lpPair)
.getReserves();
if (reserve0 == 0 || reserve1 == 0) {
return 0;
}
(uint reserveIn, uint reserveOut) = IUniswapV2Pair(lpPair).token0() ==
address(WETH)
? (reserve0, reserve1)
: (reserve1, reserve0);
return (reserveIn * 1e18) / reserveOut;
}
}
