文件 1 的 1：BitSecureToken.sol
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);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Initializable {
struct InitializableStorage {
uint64 _initialized;
bool _initializing;
}
bytes32 private constant INITIALIZABLE_STORAGE = 0xf0c57e16840df040f15088dc2f81fe391c3923bec73e23a9662efc9c229c6a00;
error InvalidInitialization();
error NotInitializing();
event Initialized(uint64 version);
modifier initializer() {
InitializableStorage storage $ = _getInitializableStorage();
bool isTopLevelCall = !$._initializing;
uint64 initialized = $._initialized;
bool initialSetup = initialized == 0 && isTopLevelCall;
bool construction = initialized == 1 && address(this).code.length == 0;
if (!initialSetup && !construction) {
revert InvalidInitialization();
}
$._initialized = 1;
if (isTopLevelCall) {
$._initializing = true;
}
_;
if (isTopLevelCall) {
$._initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint64 version) {
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing || $._initialized >= version) {
revert InvalidInitialization();
}
$._initialized = version;
$._initializing = true;
_;
$._initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
_checkInitializing();
_;
}
function _checkInitializing() internal view virtual {
if (!_isInitializing()) {
revert NotInitializing();
}
}
function _disableInitializers() internal virtual {
InitializableStorage storage $ = _getInitializableStorage();
if ($._initializing) {
revert InvalidInitialization();
}
if ($._initialized != type(uint64).max) {
$._initialized = type(uint64).max;
emit Initialized(type(uint64).max);
}
}
function _getInitializedVersion() internal view returns (uint64) {
return _getInitializableStorage()._initialized;
}
function _isInitializing() internal view returns (bool) {
return _getInitializableStorage()._initializing;
}
function _getInitializableStorage() private pure returns (InitializableStorage storage $) {
assembly {
$.slot := INITIALIZABLE_STORAGE
}
}
}
abstract contract ContextUpgradeable is Initializable {
function __Context_init() internal onlyInitializing {
}
function __Context_init_unchained() internal onlyInitializing {
}
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;
}
}
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);
}
abstract contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20, IERC20Metadata, IERC20Errors {
struct ERC20Storage {
mapping(address account => uint256) _balances;
mapping(address account => mapping(address spender => uint256)) _allowances;
uint256 _totalSupply;
string _name;
string _symbol;
}
bytes32 private constant ERC20StorageLocation = 0x52c63247e1f47db19d5ce0460030c497f067ca4cebf71ba98eeadabe20bace00;
function _getERC20Storage() private pure returns (ERC20Storage storage $) {
assembly {
$.slot := ERC20StorageLocation
}
}
function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
__ERC20_init_unchained(name_, symbol_);
}
function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
ERC20Storage storage $ = _getERC20Storage();
$._name = name_;
$._symbol = symbol_;
}
function name() public view virtual returns (string memory) {
ERC20Storage storage $ = _getERC20Storage();
return $._name;
}
function symbol() public view virtual returns (string memory) {
ERC20Storage storage $ = _getERC20Storage();
return $._symbol;
}
function decimals() public view virtual returns (uint8) {
return 18;
}
function totalSupply() public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
return $._totalSupply;
}
function balanceOf(address account) public view virtual returns (uint256) {
ERC20Storage storage $ = _getERC20Storage();
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) {
ERC20Storage storage $ = _getERC20Storage();
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 {
ERC20Storage storage $ = _getERC20Storage();
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 {
ERC20Storage storage $ = _getERC20Storage();
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);
}
}
}
}
abstract contract ERC20BurnableUpgradeable is Initializable, ContextUpgradeable, ERC20Upgradeable {
function __ERC20Burnable_init() internal onlyInitializing {
}
function __ERC20Burnable_init_unchained() internal onlyInitializing {
}
function burn(uint256 value) public virtual {
_burn(_msgSender(), value);
}
function burnFrom(address account, uint256 value) public virtual {
_spendAllowance(account, _msgSender(), value);
_burn(account, value);
}
}
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
struct PausableStorage {
bool _paused;
}
bytes32 private constant PausableStorageLocation = 0xcd5ed15c6e187e77e9aee88184c21f4f2182ab5827cb3b7e07fbedcd63f03300;
function _getPausableStorage() private pure returns (PausableStorage storage $) {
assembly {
$.slot := PausableStorageLocation
}
}
event Paused(address account);
event Unpaused(address account);
error EnforcedPause();
error ExpectedPause();
function __Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __Pausable_init_unchained() internal onlyInitializing {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
}
modifier whenNotPaused() {
_requireNotPaused();
_;
}
modifier whenPaused() {
_requirePaused();
_;
}
function paused() public view virtual returns (bool) {
PausableStorage storage $ = _getPausableStorage();
return $._paused;
}
function _requireNotPaused() internal view virtual {
if (paused()) {
revert EnforcedPause();
}
}
function _requirePaused() internal view virtual {
if (!paused()) {
revert ExpectedPause();
}
}
function _pause() internal virtual whenNotPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = true;
emit Paused(_msgSender());
}
function _unpause() internal virtual whenPaused {
PausableStorage storage $ = _getPausableStorage();
$._paused = false;
emit Unpaused(_msgSender());
}
}
abstract contract ERC20PausableUpgradeable is Initializable, ERC20Upgradeable, PausableUpgradeable {
function __ERC20Pausable_init() internal onlyInitializing {
__Pausable_init_unchained();
}
function __ERC20Pausable_init_unchained() internal onlyInitializing {
}
function _update(address from, address to, uint256 value) internal virtual override whenNotPaused {
super._update(from, to, value);
}
}
interface IAccessControl {
error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);
error AccessControlBadConfirmation();
event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
function hasRole(bytes32 role, address account) external view returns (bool);
function getRoleAdmin(bytes32 role) external view returns (bytes32);
function grantRole(bytes32 role, address account) external;
function revokeRole(bytes32 role, address account) external;
function renounceRole(bytes32 role, address callerConfirmation) external;
}
interface IERC165 {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
abstract contract ERC165Upgradeable is Initializable, IERC165 {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
return interfaceId == type(IERC165).interfaceId;
}
}
abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControl, ERC165Upgradeable {
struct RoleData {
mapping(address account => bool) hasRole;
bytes32 adminRole;
}
bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
struct AccessControlStorage {
mapping(bytes32 role => RoleData) _roles;
}
bytes32 private constant AccessControlStorageLocation = 0x02dd7bc7dec4dceedda775e58dd541e08a116c6c53815c0bd028192f7b626800;
function _getAccessControlStorage() private pure returns (AccessControlStorage storage $) {
assembly {
$.slot := AccessControlStorageLocation
}
}
modifier onlyRole(bytes32 role) {
_checkRole(role);
_;
}
function __AccessControl_init() internal onlyInitializing {
}
function __AccessControl_init_unchained() internal onlyInitializing {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
}
function hasRole(bytes32 role, address account) public view virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
return $._roles[role].hasRole[account];
}
function _checkRole(bytes32 role) internal view virtual {
_checkRole(role, _msgSender());
}
function _checkRole(bytes32 role, address account) internal view virtual {
if (!hasRole(role, account)) {
revert AccessControlUnauthorizedAccount(account, role);
}
}
function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
AccessControlStorage storage $ = _getAccessControlStorage();
return $._roles[role].adminRole;
}
function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
_grantRole(role, account);
}
function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
_revokeRole(role, account);
}
function renounceRole(bytes32 role, address callerConfirmation) public virtual {
if (callerConfirmation != _msgSender()) {
revert AccessControlBadConfirmation();
}
_revokeRole(role, callerConfirmation);
}
function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
AccessControlStorage storage $ = _getAccessControlStorage();
bytes32 previousAdminRole = getRoleAdmin(role);
$._roles[role].adminRole = adminRole;
emit RoleAdminChanged(role, previousAdminRole, adminRole);
}
function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
if (!hasRole(role, account)) {
$._roles[role].hasRole[account] = true;
emit RoleGranted(role, account, _msgSender());
return true;
} else {
return false;
}
}
function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
AccessControlStorage storage $ = _getAccessControlStorage();
if (hasRole(role, account)) {
$._roles[role].hasRole[account] = false;
emit RoleRevoked(role, account, _msgSender());
return true;
} else {
return false;
}
}
}
interface IERC1822Proxiable {
function proxiableUUID() external view returns (bytes32);
}
interface IBeacon {
function implementation() external view returns (address);
}
library Address {
error AddressInsufficientBalance(address account);
error AddressEmptyCode(address target);
error FailedInnerCall();
function sendValue(address payable recipient, uint256 amount) internal {
if (address(this).balance < amount) {
revert AddressInsufficientBalance(address(this));
}
(bool success, ) = recipient.call{value: amount}("");
if (!success) {
revert FailedInnerCall();
}
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
if (address(this).balance < value) {
revert AddressInsufficientBalance(address(this));
}
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata
) internal view returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
if (returndata.length == 0 && target.code.length == 0) {
revert AddressEmptyCode(target);
}
return returndata;
}
}
function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
if (!success) {
_revert(returndata);
} else {
return returndata;
}
}
function _revert(bytes memory returndata) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert FailedInnerCall();
}
}
}
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
}
}
}
library ERC1967Utils {
event Upgraded(address indexed implementation);
event AdminChanged(address previousAdmin, address newAdmin);
event BeaconUpgraded(address indexed beacon);
bytes32 internal constant IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
error ERC1967InvalidImplementation(address implementation);
error ERC1967InvalidAdmin(address admin);
error ERC1967InvalidBeacon(address beacon);
error ERC1967NonPayable();
function getImplementation() internal view returns (address) {
return StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value;
}
function _setImplementation(address newImplementation) private {
if (newImplementation.code.length == 0) {
revert ERC1967InvalidImplementation(newImplementation);
}
StorageSlot.getAddressSlot(IMPLEMENTATION_SLOT).value = newImplementation;
}
function upgradeToAndCall(address newImplementation, bytes memory data) internal {
_setImplementation(newImplementation);
emit Upgraded(newImplementation);
if (data.length > 0) {
Address.functionDelegateCall(newImplementation, data);
} else {
_checkNonPayable();
}
}
bytes32 internal constant ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
function getAdmin() internal view returns (address) {
return StorageSlot.getAddressSlot(ADMIN_SLOT).value;
}
function _setAdmin(address newAdmin) private {
if (newAdmin == address(0)) {
revert ERC1967InvalidAdmin(address(0));
}
StorageSlot.getAddressSlot(ADMIN_SLOT).value = newAdmin;
}
function changeAdmin(address newAdmin) internal {
emit AdminChanged(getAdmin(), newAdmin);
_setAdmin(newAdmin);
}
bytes32 internal constant BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
function getBeacon() internal view returns (address) {
return StorageSlot.getAddressSlot(BEACON_SLOT).value;
}
function _setBeacon(address newBeacon) private {
if (newBeacon.code.length == 0) {
revert ERC1967InvalidBeacon(newBeacon);
}
StorageSlot.getAddressSlot(BEACON_SLOT).value = newBeacon;
address beaconImplementation = IBeacon(newBeacon).implementation();
if (beaconImplementation.code.length == 0) {
revert ERC1967InvalidImplementation(beaconImplementation);
}
}
function upgradeBeaconToAndCall(address newBeacon, bytes memory data) internal {
_setBeacon(newBeacon);
emit BeaconUpgraded(newBeacon);
if (data.length > 0) {
Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
} else {
_checkNonPayable();
}
}
function _checkNonPayable() private {
if (msg.value > 0) {
revert ERC1967NonPayable();
}
}
}
abstract contract UUPSUpgradeable is Initializable, IERC1822Proxiable {
address private immutable __self = address(this);
string public constant UPGRADE_INTERFACE_VERSION = "5.0.0";
error UUPSUnauthorizedCallContext();
error UUPSUnsupportedProxiableUUID(bytes32 slot);
modifier onlyProxy() {
_checkProxy();
_;
}
modifier notDelegated() {
_checkNotDelegated();
_;
}
function __UUPSUpgradeable_init() internal onlyInitializing {
}
function __UUPSUpgradeable_init_unchained() internal onlyInitializing {
}
function proxiableUUID() external view virtual notDelegated returns (bytes32) {
return ERC1967Utils.IMPLEMENTATION_SLOT;
}
function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
_authorizeUpgrade(newImplementation);
_upgradeToAndCallUUPS(newImplementation, data);
}
function _checkProxy() internal view virtual {
if (
address(this) == __self ||
ERC1967Utils.getImplementation() != __self
) {
revert UUPSUnauthorizedCallContext();
}
}
function _checkNotDelegated() internal view virtual {
if (address(this) != __self) {
revert UUPSUnauthorizedCallContext();
}
}
function _authorizeUpgrade(address newImplementation) internal virtual;
function _upgradeToAndCallUUPS(address newImplementation, bytes memory data) private {
try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
if (slot != ERC1967Utils.IMPLEMENTATION_SLOT) {
revert UUPSUnsupportedProxiableUUID(slot);
}
ERC1967Utils.upgradeToAndCall(newImplementation, data);
} catch {
revert ERC1967Utils.ERC1967InvalidImplementation(newImplementation);
}
}
}
abstract contract ReentrancyGuard {
uint256 private constant _NOT_ENTERED = 1;
uint256 private constant _ENTERED = 2;
uint256 private _status;
constructor() {
_status = _NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
}
function _nonReentrantAfter() private {
_status = _NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == _ENTERED;
}
}
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);
}
library SafeERC20 {
using Address for address;
error SafeERC20FailedOperation(address token);
error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
forceApprove(token, spender, oldAllowance + value);
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
unchecked {
uint256 currentAllowance = token.allowance(address(this), spender);
if (currentAllowance < requestedDecrease) {
revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
}
forceApprove(token, spender, currentAllowance - requestedDecrease);
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
_callOptionalReturn(token, approvalCall);
}
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data);
if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
revert SafeERC20FailedOperation(address(token));
}
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
}
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidity(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB);
function removeLiquidityETH(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountToken, uint amountETH);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function removeLiquidityETHWithPermit(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountToken, uint amountETH);
function swapExactTokensForTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapTokensForExactTokens(
uint amountOut,
uint amountInMax,
address[] calldata path,
address to,
uint deadline
) external returns (uint[] memory amounts);
function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
external
returns (uint[] memory amounts);
function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
external
payable
returns (uint[] memory amounts);
function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}
pragma solidity >=0.6.2 <0.9.0;
interface IUniswapV2Router02 is IUniswapV2Router01 {
function removeLiquidityETHSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external returns (uint amountETH);
function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
address token,
uint liquidity,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountETH);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
pragma solidity >=0.5.0;
interface IUniswapV3SwapCallback {
function uniswapV3SwapCallback(
int256 amount0Delta,
int256 amount1Delta,
bytes calldata data
) external;
}
pragma solidity >=0.7.5;
interface ISwapRouter is IUniswapV3SwapCallback {
struct ExactInputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
uint160 sqrtPriceLimitX96;
}
function exactInputSingle(ExactInputSingleParams calldata params) external payable returns (uint256 amountOut);
struct ExactInputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountIn;
uint256 amountOutMinimum;
}
function exactInput(ExactInputParams calldata params) external payable returns (uint256 amountOut);
struct ExactOutputSingleParams {
address tokenIn;
address tokenOut;
uint24 fee;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
uint160 sqrtPriceLimitX96;
}
function exactOutputSingle(ExactOutputSingleParams calldata params) external payable returns (uint256 amountIn);
struct ExactOutputParams {
bytes path;
address recipient;
uint256 deadline;
uint256 amountOut;
uint256 amountInMaximum;
}
function exactOutput(ExactOutputParams calldata params) external payable returns (uint256 amountIn);
}
pragma solidity >=0.5.0;
interface IUniswapV3Factory {
event OwnerChanged(address indexed oldOwner, address indexed newOwner);
event PoolCreated(
address indexed token0,
address indexed token1,
uint24 indexed fee,
int24 tickSpacing,
address pool
);
event FeeAmountEnabled(uint24 indexed fee, int24 indexed tickSpacing);
function owner() external view returns (address);
function feeAmountTickSpacing(uint24 fee) external view returns (int24);
function getPool(
address tokenA,
address tokenB,
uint24 fee
) external view returns (address pool);
function createPool(
address tokenA,
address tokenB,
uint24 fee
) external returns (address pool);
function setOwner(address _owner) external;
function enableFeeAmount(uint24 fee, int24 tickSpacing) external;
}
interface IERC721 is IERC165 {
event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
event ApprovalForAll(address indexed owner, address indexed operator, bool approved);
function balanceOf(address owner) external view returns (uint256 balance);
function ownerOf(uint256 tokenId) external view returns (address owner);
function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
function safeTransferFrom(address from, address to, uint256 tokenId) external;
function transferFrom(address from, address to, uint256 tokenId) external;
function approve(address to, uint256 tokenId) external;
function setApprovalForAll(address operator, bool approved) external;
function getApproved(uint256 tokenId) external view returns (address operator);
function isApprovedForAll(address owner, address operator) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC721Metadata is IERC721 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {
function totalSupply() external view returns (uint256);
function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);
function tokenByIndex(uint256 index) external view returns (uint256);
}
pragma solidity >=0.7.5;
interface IPoolInitializer {
function createAndInitializePoolIfNecessary(
address token0,
address token1,
uint24 fee,
uint160 sqrtPriceX96
) external payable returns (address pool);
}
pragma solidity >=0.7.5;
interface IERC721Permit is IERC721 {
function PERMIT_TYPEHASH() external pure returns (bytes32);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function permit(
address spender,
uint256 tokenId,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external payable;
}
pragma solidity >=0.7.5;
interface IPeripheryPayments {
function unwrapWETH9(uint256 amountMinimum, address recipient) external payable;
function refundETH() external payable;
function sweepToken(
address token,
uint256 amountMinimum,
address recipient
) external payable;
}
pragma solidity >=0.5.0;
interface IPeripheryImmutableState {
function factory() external view returns (address);
function WETH9() external view returns (address);
}
pragma solidity >=0.5.0;
library PoolAddress {
bytes32 internal constant POOL_INIT_CODE_HASH = 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54;
struct PoolKey {
address token0;
address token1;
uint24 fee;
}
function getPoolKey(
address tokenA,
address tokenB,
uint24 fee
) internal pure returns (PoolKey memory) {
if (tokenA > tokenB) (tokenA, tokenB) = (tokenB, tokenA);
return PoolKey({token0: tokenA, token1: tokenB, fee: fee});
}
function computeAddress(address factory, PoolKey memory key) internal pure returns (address pool) {
require(key.token0 < key.token1);
bytes32 hash = keccak256(
abi.encodePacked(
hex'ff',
factory,
keccak256(abi.encode(key.token0, key.token1, key.fee)),
POOL_INIT_CODE_HASH
)
);
pool = address(uint160(uint256(hash)));
}
}
pragma solidity >=0.7.5;
interface INonfungiblePositionManager is
IPoolInitializer,
IPeripheryPayments,
IPeripheryImmutableState,
IERC721Metadata,
IERC721Enumerable,
IERC721Permit
{
event IncreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
event DecreaseLiquidity(uint256 indexed tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);
event Collect(uint256 indexed tokenId, address recipient, uint256 amount0, uint256 amount1);
function positions(uint256 tokenId)
external
view
returns (
uint96 nonce,
address operator,
address token0,
address token1,
uint24 fee,
int24 tickLower,
int24 tickUpper,
uint128 liquidity,
uint256 feeGrowthInside0LastX128,
uint256 feeGrowthInside1LastX128,
uint128 tokensOwed0,
uint128 tokensOwed1
);
struct MintParams {
address token0;
address token1;
uint24 fee;
int24 tickLower;
int24 tickUpper;
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0Min;
uint256 amount1Min;
address recipient;
uint256 deadline;
}
function mint(MintParams calldata params)
external
payable
returns (
uint256 tokenId,
uint128 liquidity,
uint256 amount0,
uint256 amount1
);
struct IncreaseLiquidityParams {
uint256 tokenId;
uint256 amount0Desired;
uint256 amount1Desired;
uint256 amount0Min;
uint256 amount1Min;
uint256 deadline;
}
function increaseLiquidity(IncreaseLiquidityParams calldata params)
external
payable
returns (
uint128 liquidity,
uint256 amount0,
uint256 amount1
);
struct DecreaseLiquidityParams {
uint256 tokenId;
uint128 liquidity;
uint256 amount0Min;
uint256 amount1Min;
uint256 deadline;
}
function decreaseLiquidity(DecreaseLiquidityParams calldata params)
external
payable
returns (uint256 amount0, uint256 amount1);
struct CollectParams {
uint256 tokenId;
address recipient;
uint128 amount0Max;
uint128 amount1Max;
}
function collect(CollectParams calldata params) external payable returns (uint256 amount0, uint256 amount1);
function burn(uint256 tokenId) external payable;
}
pragma solidity ^0.8.0;
interface AggregatorV3Interface {
function decimals() external view returns (uint8);
function description() external view returns (string memory);
function version() external view returns (uint256);
function getRoundData(
uint80 _roundId
) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
function latestRoundData()
external
view
returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}
pragma solidity ^0.8.0;
library SafeMath {
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 add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
interface IBitSecureLibrary {
function calculateBonus(uint256 amount) external view returns (uint256);
}
struct DexInfo {
address router;
address tokenB;
}
contract BitSecureToken is Initializable, ERC20Upgradeable, ERC20BurnableUpgradeable, ERC20PausableUpgradeable, AccessControlUpgradeable, UUPSUpgradeable, ReentrancyGuard {
using SafeERC20 for IERC20;
using Address for address payable;
using SafeMath for uint256;
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");
bytes32 public constant WHITELISTER_ROLE = keccak256("WHITELISTER_ROLE");
bytes32 public constant FOUNDER_ROLE = keccak256("FOUNDER_ROLE");
address public founder1;
address public founder2;
address public founder3;
uint256 private feeBalance;
uint256 private lastDistribution;
uint256 private distributionInterval;
uint256 private upgradeTimeLock;
ISwapRouter public swapRouter;
address private uniswapPool;
address private immutable WETH;
address private immutable libraryAddress;
address private immutable notesAddress;
address private contractOwner;
uint256 private baseFeePercentage;
uint256 private whaleFeePercentageSell;
uint256 private whaleFeePercentageBuy;
uint256 private whaleThreshold;
uint256 private blockReward;
uint256 private referralBonusPercentage;
uint256 private totalSupplyCap;
bool private useKeepers;
uint256 private lastManualUpdate;
uint256 private manualUpdateInterval;
uint256 private constant EVM_VERSION = 3;
uint256 private dynamicFeeAdjustmentFactor;
uint256 private dynamicFeeCap;
uint256 private initialCooldownPeriod;
uint256 private baseCooldownPeriod;
uint256 private highVolumeThreshold;
uint256 private lowVolumeThreshold;
uint256 private highVolumeCooldown;
uint256 private lowVolumeCooldown;
uint256 private volumeResetInterval;
uint256 private cooldownPenaltyFeePercentage;
uint256 private minimumPurchaseUSD;
uint256 private maximumPurchaseUSD;
uint256 private GALACTIC_THRESHOLD;
uint256 private DIAMOND_HANDS_THRESHOLD;
uint256 private TITANIUM_THRESHOLD;
uint256 private GOLD_THRESHOLD;
uint256 private SILVER_THRESHOLD;
uint256 private FIRST_PURCHASE_BONUS;
uint256 private SECOND_PURCHASE_BONUS;
uint256 private THIRD_PURCHASE_BONUS;
uint256 private FOURTH_PURCHASE_BONUS;
uint256 private FIFTH_PURCHASE_BONUS;
uint256 private PURCHASE_CAP;
uint256 private MAX_FEE_PERCENTAGE;
uint256 private REFERRAL_REWARD;
uint256 private MAX_SUPPLY;
uint256 private MAX_MINER_REWARD_PER_BLOCK;
INonfungiblePositionManager public uniswapV3PositionManager;
AggregatorV3Interface public priceFeed;
AggregatorV3Interface public ethUsdPriceFeed;
uint256 public stakingRewardRate;
uint256 public rewardDistributionInterval;
uint256 public proposalVotingPeriod;
uint256 public quorumRequirement;
uint256 public proposalExecutionTime;
uint256 public liquidityMiningRewardRate;
uint256 public liquidityMiningDuration;
string[] public rewardTiers;
uint256[] public rewardRates;
mapping(address => bool) private whitelist;
mapping(address => uint256) private lastTransactionTime;
mapping(address => uint256) private penaltyCounter;
mapping(address => bytes32) private referralCodes;
mapping(address => uint256) private referralRewards;
mapping(address => uint256) private referralSales;
mapping(address => uint256) private stakedBalances;
mapping(address => address) private referredBy;
mapping(address => uint256) private totalPurchaseAmount;
mapping(address => uint256) private purchaseCount;
mapping(address => uint256) private lastPurchaseTime;
mapping(string => DexInfo) private dexes;
mapping(string => bool) private dexExists;
mapping(bytes4 => bool) public pausedFunctions;
event FeeCollected(uint256 fee);
event FeeDistributed(uint256 amount);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event Whitelisted(address indexed account);
event RemovedFromWhitelist(address indexed account);
event CooldownPeriodAdjusted(uint256 newCooldownPeriod);
event BlockRewardAdjusted(uint256 newBlockReward);
event BaseFeePercentageUpdated(uint256 newBaseFeePercentage);
event WhaleFeePercentageUpdated(uint256 newWhaleFeePercentage);
event WhaleThresholdUpdated(uint256 newWhaleThreshold);
event DeFiIntegration(address indexed protocol);
event TokensStaked(address indexed user, uint256 amount);
event TokensUnstaked(address indexed user, uint256 amount);
event ReferralCodeUsed(address indexed buyer, address indexed referrer, uint256 amount);
event RewardsDistributed(address indexed referrer, uint256 reward);
event ReferralRewardClaimed(address indexed user, bytes32 referralCode);
event ReferralCodeGenerated(address indexed user, bytes32 referralCode);
event TokensPurchased(address indexed buyer, uint256 ethAmount, uint256 tokenAmount);
event TokensSold(address indexed seller, uint256 tokenAmount, uint256 ethAmount);
event UpgradePrepared(address newImplementation, uint256 upgradeTimeLock);
event UpgradeFinalized(address newImplementation);
event ReferralReward(address indexed referrer, address indexed buyer, uint256 reward);
event ProposalCreated(uint256 indexed proposalId, string description, uint256 deadline);
event VoteCast(address indexed voter, uint256 indexed proposalId, bool support);
event TransactionRecorded(address indexed user, uint256 amount, uint256 timestamp);
event AuditRecorded(address indexed user, string action, uint256 timestamp);
event TokenMinted(address indexed recipient, uint256 amount);
event TokenBurned(address indexed account, uint256 amount);
event LiquidityProvided(address indexed provider, uint256 amount);
event LiquidityRewardsDistributed(address indexed provider, uint256 reward);
event RewardDistributed(address indexed user, uint256 amount);
error Unauthorized();
error InsufficientBalance(uint256 available, uint256 required);
error InvalidAddress(address invalid);
modifier onlyOwner() {
if (msg.sender != contractOwner) revert Unauthorized();
_;
}
modifier onlyWhitelister() {
require(hasRole(WHITELISTER_ROLE, msg.sender), "Caller is not a whitelister");
_;
}
modifier onlyAfterTimeLock() {
require(block.timestamp >= upgradeTimeLock, "Upgrade is time-locked");
_;
}
modifier onlyFounder() {
require(hasRole(FOUNDER_ROLE, msg.sender), "Caller is not a founder");
_;
}
modifier onlyAuthorized() {
require(hasRole(DEFAULT_ADMIN_ROLE, msg.sender) || hasRole(FOUNDER_ROLE, msg.sender), "Not authorized");
_;
}
modifier whenFunctionNotPaused(bytes4 funcSig) {
require(!pausedFunctions[funcSig], "Function is paused");
_;
}
constructor(address _libraryAddress, address _notesAddress) {
swapRouter = ISwapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
contractOwner = msg.sender;
libraryAddress = _libraryAddress;
notesAddress = _notesAddress;
}
function initialize(
address _founder1,
address _founder2,
address _founder3
) initializer public {
require(_founder1 != address(0) && _founder2 != address(0) && _founder3 != address(0), "Invalid founder address");
__ERC20_init("Bitsee (Btcsec) by BitSecure", "BTCSEC");
__ERC20Burnable_init();
__ERC20Pausable_init();
__AccessControl_init();
__UUPSUpgradeable_init();
uint256 initialSupply = 99000000000000000000000000000;
uint256 founderAllocation = (initialSupply * 60) / 100;
uint256 contractAllocation = initialSupply - founderAllocation;
uint256 perFounderAllocation = founderAllocation / 3;
_mint(address(this), contractAllocation);
founder1 = _founder1;
founder2 = _founder2;
founder3 = _founder3;
_mint(founder1, perFounderAllocation);
_mint(founder2, perFounderAllocation);
_mint(founder3, perFounderAllocation);
_initializeVariables();
_initializeTokenomics();
_initializeCooldown();
_initializeReferral();
_initializeFounders();
_tryInitializeUniswap(0x1F98431c8aD98523631AE4a59f267346ea31F984);
_initializePriceFeeds(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419);
_initializeThresholds();
emit OwnershipTransferred(address(0), contractOwner);
}
function _initializeVariables() private {
baseFeePercentage = 15;
dynamicFeeAdjustmentFactor = 100;
dynamicFeeCap = 75;
distributionInterval = 86400;
initialCooldownPeriod = 1800;
baseCooldownPeriod = 1800;
highVolumeThreshold = 660000000 * 10**18;
lowVolumeThreshold = 6600000 * 10**18;
highVolumeCooldown = 7200;
lowVolumeCooldown = 1800;
volumeResetInterval = 86400;
cooldownPenaltyFeePercentage = 10;
referralBonusPercentage = 1;
blockReward = 150 * 10**18;
minimumPurchaseUSD = 1;
maximumPurchaseUSD = 10000;
GALACTIC_THRESHOLD = 1000000 * 10**18;
DIAMOND_HANDS_THRESHOLD = 500000 * 10**18;
TITANIUM_THRESHOLD = 250000 * 10**18;
GOLD_THRESHOLD = 100000 * 10**18;
SILVER_THRESHOLD = 50000 * 10**18;
whaleFeePercentageSell = 15 * 100;
whaleFeePercentageBuy = 375;
whaleThreshold = 100000 * 10**18;
stakingRewardRate = 5;
rewardDistributionInterval = 86400;
proposalVotingPeriod = 604800;
quorumRequirement = 20;
proposalExecutionTime = 172800;
liquidityMiningRewardRate = 2;
liquidityMiningDuration = 2592000;
rewardTiers = ["Bronze", "Silver", "Gold", "Platinum"];
rewardRates = [1, 2, 3, 4];
}
function _initializeTokenomics() private {
FIRST_PURCHASE_BONUS = 1;
SECOND_PURCHASE_BONUS = 3;
THIRD_PURCHASE_BONUS = 5;
FOURTH_PURCHASE_BONUS = 7;
FIFTH_PURCHASE_BONUS = 10;
PURCHASE_CAP = 12;
MAX_FEE_PERCENTAGE = 20;
REFERRAL_REWARD = 4500 * 10**18;
MAX_SUPPLY = 1000000000 * 10**18;
MAX_MINER_REWARD_PER_BLOCK = 10 * 10**18;
}
function _initializeCooldown() private {
initialCooldownPeriod = 1800;
baseCooldownPeriod = 1800;
highVolumeThreshold = 660000000 * 10**18;
lowVolumeThreshold = 6600000 * 10**18;
highVolumeCooldown = 7200;
lowVolumeCooldown = 1800;
volumeResetInterval = 86400;
cooldownPenaltyFeePercentage = 10;
}
function _initializeReferral() private {
referralBonusPercentage = 1;
REFERRAL_REWARD = 4500 * 10**18;
}
function _initializeFounders() private {
address[] memory founders = new address[](3);
founders[0] = founder1;
founders[1] = founder2;
founders[2] = founder3;
for (uint256 i = 0; i < founders.length; i++) {
_grantRole(DEFAULT_ADMIN_ROLE, founders[i]);
_grantRole(PAUSER_ROLE, founders[i]);
_grantRole(MINTER_ROLE, founders[i]);
_grantRole(BURNER_ROLE, founders[i]);
_grantRole(WHITELISTER_ROLE, founders[i]);
}
_grantRole(DEFAULT_ADMIN_ROLE, 0xc2c5871A2B448d10d8762C81fC90F028B6163B0E);
}
function _tryInitializeUniswap(address factoryAddress) private {
require(factoryAddress != address(0), "Invalid factory address");
uniswapV3PositionManager = INonfungiblePositionManager(0xC36442b4a4522E871399CD717aBDD847Ab11FE88);
address tokenA = address(this);
address tokenB = WETH;
uint24 fee = 3000;
address uniswapFactory = factoryAddress;
try IUniswapV3Factory(uniswapFactory).getPool(tokenA, tokenB, fee) returns (address pool) {
if (pool == address(0)) {
try IUniswapV3Factory(uniswapFactory).createPool(tokenA, tokenB, fee) returns (address newPool) {
uniswapPool = newPool;
} catch {
uniswapPool = address(0);
}
} else {
uniswapPool = pool;
}
} catch {
uniswapPool = address(0);
}
}
function _initializePriceFeeds(address priceFeedAddress) private {
require(priceFeedAddress != address(0), "Invalid price feed address");
priceFeed = AggregatorV3Interface(priceFeedAddress);
ethUsdPriceFeed = AggregatorV3Interface(priceFeedAddress);
}
function _initializeThresholds() private {
whaleThreshold = 100000 * 10**18;
GALACTIC_THRESHOLD = 1000000 * 10**18;
DIAMOND_HANDS_THRESHOLD = 500000 * 10**18;
TITANIUM_THRESHOLD = 250000 * 10**18;
GOLD_THRESHOLD = 100000 * 10**18;
SILVER_THRESHOLD = 50000 * 10**18;
}
function changeFounderAddress(uint8 founderIndex, address newAddress) external onlyFounder {
require(newAddress != address(0), "Invalid address");
if (founderIndex == 1) {
founder1 = newAddress;
} else if (founderIndex == 2) {
founder2 = newAddress;
} else if (founderIndex == 3) {
founder3 = newAddress;
} else {
revert("Invalid founder index");
}
}
function buyToken(address referrer) public payable nonReentrant {
require(msg.value > 0, "You need to send some Ether");
(, int price, , , ) = ethUsdPriceFeed.latestRoundData();
require(price > 0, "Invalid ETH/USD price");
uint256 tokenPriceInEth = uint256(1.50 * 10**18) / uint256(price);
uint256 tokensToBuy = msg.value * tokenPriceInEth;
require(balanceOf(address(this)) >= tokensToBuy, "Insufficient tokens");
_transfer(address(this), msg.sender, tokensToBuy);
if (tokensToBuy >= whaleThreshold) {
uint256 whaleFee = tokensToBuy * whaleFeePercentageBuy / 10000;
_burn(msg.sender, whaleFee);
tokensToBuy -= whaleFee;
}
if (referrer != address(0) && referrer != msg.sender) {
uint256 referralBonus = IBitSecureLibrary(libraryAddress).calculateBonus(tokensToBuy);
referralRewards[referrer] += referralBonus;
referralSales[referrer] += tokensToBuy;
referredBy[msg.sender] = referrer;
_transfer(address(this), referrer, referralBonus);
emit ReferralReward(referrer, msg.sender, referralBonus);
}
emit TokensPurchased(msg.sender, msg.value, tokensToBuy);
}
function getUserTier(address user) public view returns (string memory) {
uint256 total = totalPurchaseAmount[user];
if (total >= GALACTIC_THRESHOLD) return "Galactic Bitsee";
if (total >= DIAMOND_HANDS_THRESHOLD) return "Diamond Hands Bitsee";
if (total >= TITANIUM_THRESHOLD) return "Titanium Bitsee";
if (total >= GOLD_THRESHOLD) return "Gold Bitsee";
if (total >= SILVER_THRESHOLD) return "Silver Bitsee";
return "Bronze Bitsee";
}
function getDisclaimerAndMessage() public view returns (string memory, string memory) {
(bool successDisclaimer, bytes memory dataDisclaimer) = notesAddress.staticcall(abi.encodeWithSignature("LEGAL_DISCLAIMER()"));
(bool successMessage, bytes memory dataMessage) = notesAddress.staticcall(abi.encodeWithSignature("SECRET_MESSAGE()"));
require(successDisclaimer && successMessage, "Call to BitseeNotes failed");
return (abi.decode(dataDisclaimer, (string)), abi.decode(dataMessage, (string)));
}
function mintTokens(address recipient, uint256 amount) public {
require(hasRole(FOUNDER_ROLE, msg.sender), "Caller is not a founder");
_mint(recipient, amount);
emit TokenMinted(recipient, amount);
}
function burnTokens(address account, uint256 amount) public {
require(hasRole(FOUNDER_ROLE, msg.sender), "Caller is not a founder");
_burn(account, amount);
emit TokenBurned(account, amount);
}
function stakeTokens(uint256 amount) public {
_transfer(msg.sender, address(this), amount);
stakedBalances[msg.sender] += amount;
emit TokensStaked(msg.sender, amount);
}
function unstakeTokens(uint256 amount) public {
require(stakedBalances[msg.sender] >= amount, "Insufficient staked balance");
stakedBalances[msg.sender] -= amount;
_transfer(address(this), msg.sender, amount);
emit TokensUnstaked(msg.sender, amount);
}
function provideLiquidity(uint256 amountA, uint256 amountB) public {
IUniswapV2Router02(address(swapRouter)).addLiquidity(
address(this),
WETH,
amountA,
amountB,
0,
0,
msg.sender,
block.timestamp
);
emit LiquidityProvided(msg.sender, amountA);
}
function distributeLiquidityRewards(address provider, uint256 reward) internal {
_mint(provider, reward);
emit LiquidityRewardsDistributed(provider, reward);
}
struct Proposal {
string description;
uint256 votesFor;
uint256 votesAgainst;
uint256 deadline;
bool executed;
}
Proposal[] public proposals;
mapping(address => mapping(uint256 => bool)) public hasVoted;
function createProposal(string memory description) public onlyRole(DEFAULT_ADMIN_ROLE) {
proposals.push(Proposal({
description: description,
votesFor: 0,
votesAgainst: 0,
deadline: block.timestamp + proposalVotingPeriod,
executed: false
}));
emit ProposalCreated(proposals.length - 1, description, block.timestamp + proposalVotingPeriod);
}
function vote(uint256 proposalId, bool support) public {
require(proposalId < proposals.length, "Invalid proposal");
require(!hasVoted[msg.sender][proposalId], "Already voted");
require(block.timestamp < proposals[proposalId].deadline, "Voting closed");
hasVoted[msg.sender][proposalId] = true;
if (support) {
proposals[proposalId].votesFor += balanceOf(msg.sender);
} else {
proposals[proposalId].votesAgainst += balanceOf(msg.sender);
}
emit VoteCast(msg.sender, proposalId, support);
}
function executeProposal(uint256 proposalId) public onlyRole(DEFAULT_ADMIN_ROLE) {
require(proposalId < proposals.length, "Invalid proposal");
Proposal storage proposal = proposals[proposalId];
require(block.timestamp >= proposal.deadline, "Voting period not ended");
require(!proposal.executed, "Proposal already executed");
if (proposal.votesFor > proposal.votesAgainst && proposal.votesFor >= quorumRequirement * totalSupply() / 100) {
proposal.executed = true;
}
}
function recoverTokens(address token, uint256 amount) external onlyOwner {
require(token != address(this), "Cannot recover native token");
IERC20(token).transfer(msg.sender, amount);
}
function recoverEth() external onlyOwner {
payable(msg.sender).transfer(address(this).balance);
}
function emergencyWithdraw() external onlyOwner {
uint256 balance = address(this).balance;
require(balance > 0, "No balance to withdraw");
payable(msg.sender).transfer(balance);
}
function emergencyPause() external onlyOwner {
_pause();
}
function emergencyUnpause() external onlyOwner {
_unpause();
}
function prepareUpgrade(address newImplementation) external onlyOwner {
upgradeTimeLock = block.timestamp + 2 days;
emit UpgradePrepared(newImplementation, upgradeTimeLock);
}
function finalizeUpgrade(address newImplementation) external onlyOwner onlyAfterTimeLock {
_authorizeUpgrade(newImplementation);
upgradeToAndCall(newImplementation, "");
emit UpgradeFinalized(newImplementation);
}
function _authorizeUpgrade(address newImplementation) internal override onlyOwner {
}
function _update(address from, address to, uint256 value) internal override(ERC20Upgradeable, ERC20PausableUpgradeable) {
super._update(from, to, value);
}
function renounceOwnership() public onlyOwner {
emit OwnershipTransferred(contractOwner, address(0));
contractOwner = address(0);
}
function setBonusPercentages(uint256 _first, uint256 _second, uint256 _third, uint256 _fourth, uint256 _fifth) public onlyRole(FOUNDER_ROLE) {
FIRST_PURCHASE_BONUS = _first;
SECOND_PURCHASE_BONUS = _second;
THIRD_PURCHASE_BONUS = _third;
FOURTH_PURCHASE_BONUS = _fourth;
FIFTH_PURCHASE_BONUS = _fifth;
}
mapping(address => uint256) staffSales;
mapping(address => uint256) staffReferralRewards;
event StaffSaleRecorded(address indexed staff, uint256 amount);
event StaffReferralRewardRecorded(address indexed staff, uint256 reward);
function recordStaffSale(address staff, uint256 amount) external onlyAuthorized {
staffSales[staff] += amount;
emit StaffSaleRecorded(staff, amount);
}
function recordStaffReferralReward(address staff, uint256 reward) external onlyAuthorized {
staffReferralRewards[staff] += reward;
emit StaffReferralRewardRecorded(staff, reward);
}
function getStaffSales(address staff) public view returns (uint256) {
return staffSales[staff];
}
function getStaffReferralRewards(address staff) public view returns (uint256) {
return staffReferralRewards[staff];
}
function withdraw(uint256 amount) public {
if (msg.sender != contractOwner) revert Unauthorized();
if (balanceOf(msg.sender) < amount) revert InsufficientBalance(balanceOf(msg.sender), amount);
_transfer(msg.sender, address(this), amount);
}
function payStaff(address staffPayAddress) external onlyFounder {
}
function generateReport() external onlyFounder returns (string memory) {
}
function getStaffPerformance(address performanceAddress) external view onlyFounder returns (uint256 sales, uint256 rewards) {
}
}
