文件 1 的 1：StandardToken.sol
pragma solidity ^0.8.17;
interface IKARMAAntiBot {
function setTokenOwner(address owner) external;
function launch(address pair, address router) external;
function onPreTransferCheck(
address from,
address to,
uint256 amount
) external;
}
pragma solidity ^0.8.0;
interface IERC1363Spender {
function onApprovalReceived(
address sender,
uint256 amount,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC1363Receiver {
function onTransferReceived(
address operator,
address sender,
uint256 amount,
bytes calldata data
) external returns (bytes4);
}
pragma solidity ^0.8.0;
interface IERC165Upgradeable {
function supportsInterface(bytes4 interfaceId) external view returns (bool);
}
pragma solidity ^0.8.0;
interface IERC20PermitUpgradeable {
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.0;
library SafeMathUpgradeable {
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;
}
}
}
pragma solidity ^0.8.0;
interface IERC20Upgradeable {
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 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
pragma solidity ^0.8.0;
interface IERC1363 is IERC165Upgradeable, IERC20Upgradeable {
function transferAndCall(address recipient, uint256 amount) external returns (bool);
function transferAndCall(
address recipient,
uint256 amount,
bytes calldata data
) external returns (bool);
function transferFromAndCall(
address sender,
address recipient,
uint256 amount
) external returns (bool);
function transferFromAndCall(
address sender,
address recipient,
uint256 amount,
bytes calldata data
) external returns (bool);
function approveAndCall(address spender, uint256 amount) external returns (bool);
function approveAndCall(
address spender,
uint256 amount,
bytes calldata data
) external returns (bool);
}
pragma solidity ^0.8.0;
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
pragma solidity ^0.8.0;
interface IToken is IERC20MetadataUpgradeable {
struct Taxes {
uint256 marketing;
uint256 reflection;
}
struct TokenData {
string name;
string symbol;
uint8 decimals;
uint256 supply;
uint256 maxTx;
uint256 maxWallet;
address routerAddress;
address karmaDeployer;
Taxes buyTax;
Taxes sellTax;
address marketingWallet;
address rewardToken;
address antiBot;
address limitedOwner;
address karmaCampaignFactory;
}
function initialize(TokenData memory tokenData) external;
function updateExcludedFromFees(address _address, bool state) external;
function excludedFromFees(address _address) external view returns (bool);
function getOwner() external view returns (address);
}
pragma solidity ^0.8.1;
library AddressUpgradeable {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
function sendValue(address payable recipient, uint256 amount) internal {
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{value: amount}("");
require(success, "Address: unable to send value, recipient may have reverted");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
}
function functionCallWithValue(
address target,
bytes memory data,
uint256 value,
string memory errorMessage
) internal returns (bytes memory) {
require(address(this).balance >= value, "Address: insufficient balance for call");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
pragma solidity ^0.8.0;
library SafeERC20Upgradeable {
using AddressUpgradeable for address;
function safeTransfer(IERC20Upgradeable token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20Upgradeable token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20Upgradeable token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20Upgradeable token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20Upgradeable token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20PermitUpgradeable token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20Upgradeable token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20Upgradeable 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))) && AddressUpgradeable.isContract(address(token));
}
}
pragma solidity ^0.8.2;
abstract contract Initializable {
uint8 private _initialized;
bool private _initializing;
event Initialized(uint8 version);
modifier initializer() {
bool isTopLevelCall = !_initializing;
require(
(isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
"Initializable: contract is already initialized"
);
_initialized = 1;
if (isTopLevelCall) {
_initializing = true;
}
_;
if (isTopLevelCall) {
_initializing = false;
emit Initialized(1);
}
}
modifier reinitializer(uint8 version) {
require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
_initialized = version;
_initializing = true;
_;
_initializing = false;
emit Initialized(version);
}
modifier onlyInitializing() {
require(_initializing, "Initializable: contract is not initializing");
_;
}
function _disableInitializers() internal virtual {
require(!_initializing, "Initializable: contract is initializing");
if (_initialized != type(uint8).max) {
_initialized = type(uint8).max;
emit Initialized(type(uint8).max);
}
}
function _getInitializedVersion() internal view returns (uint8) {
return _initialized;
}
function _isInitializing() internal view returns (bool) {
return _initializing;
}
}
pragma solidity ^0.8.0;
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
function __ERC165_init() internal onlyInitializing {
}
function __ERC165_init_unchained() internal onlyInitializing {
}
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
return interfaceId == type(IERC165Upgradeable).interfaceId;
}
uint256[50] private __gap;
}
pragma solidity ^0.8.0;
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;
}
uint256[50] private __gap;
}
pragma solidity ^0.8.0;
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
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 {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
uint256[45] private __gap;
}
pragma solidity ^0.8.0;
abstract contract ERC1363 is IERC1363, ERC165Upgradeable, ERC20Upgradeable {
using AddressUpgradeable for address;
function supportsInterface(bytes4 interfaceId)
public
view
virtual
override(ERC165Upgradeable, IERC165Upgradeable)
returns (bool)
{
return interfaceId == type(IERC1363).interfaceId || super.supportsInterface(interfaceId);
}
function transferAndCall(address recipient, uint256 amount) public virtual override returns (bool) {
return transferAndCall(recipient, amount, '');
}
function transferAndCall(
address recipient,
uint256 amount,
bytes memory data
) public virtual override returns (bool) {
transfer(recipient, amount);
require(_checkAndCallTransfer(_msgSender(), recipient, amount, data), 'ERC1363: _checkAndCallTransfer reverts');
return true;
}
function transferFromAndCall(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
return transferFromAndCall(sender, recipient, amount, '');
}
function transferFromAndCall(
address sender,
address recipient,
uint256 amount,
bytes memory data
) public virtual override returns (bool) {
transferFrom(sender, recipient, amount);
require(_checkAndCallTransfer(sender, recipient, amount, data), 'ERC1363: _checkAndCallTransfer reverts');
return true;
}
function approveAndCall(address spender, uint256 amount) public virtual override returns (bool) {
return approveAndCall(spender, amount, '');
}
function approveAndCall(
address spender,
uint256 amount,
bytes memory data
) public virtual override returns (bool) {
approve(spender, amount);
require(_checkAndCallApprove(spender, amount, data), 'ERC1363: _checkAndCallApprove reverts');
return true;
}
function _checkAndCallTransfer(
address sender,
address recipient,
uint256 amount,
bytes memory data
) internal virtual returns (bool) {
if (!recipient.isContract()) {
return false;
}
bytes4 retval = IERC1363Receiver(recipient).onTransferReceived(_msgSender(), sender, amount, data);
return (retval == IERC1363Receiver(recipient).onTransferReceived.selector);
}
function _checkAndCallApprove(
address spender,
uint256 amount,
bytes memory data
) internal virtual returns (bool) {
if (!spender.isContract()) {
return false;
}
bytes4 retval = IERC1363Spender(spender).onApprovalReceived(_msgSender(), amount, data);
return (retval == IERC1363Spender(spender).onApprovalReceived.selector);
}
}
pragma solidity ^0.8.0;
abstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function __Ownable_init() internal onlyInitializing {
__Ownable_init_unchained();
}
function __Ownable_init_unchained() internal onlyInitializing {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
uint256[49] private __gap;
}
pragma solidity ^0.8.0;
contract LimitedOwner is OwnableUpgradeable {
address private _limitedOwner;
address public karmaCampaignFactory;
event LimitedOwnerTransferred(
address recipient
);
modifier onlyLimitedOrOwner() {
require(msg.sender == _limitedOwner || msg.sender == karmaCampaignFactory || msg.sender == owner());
_;
}
function limitedOwner() public view returns (address) {
return _limitedOwner;
}
function transferLimitedOwner(address recipient) public onlyLimitedOrOwner {
require(recipient != address(0));
_limitedOwner = recipient;
emit LimitedOwnerTransferred(_limitedOwner);
}
}
pragma solidity ^0.8.0;
contract ERC20TokenRecover is OwnableUpgradeable {
using SafeERC20Upgradeable for IERC20Upgradeable;
function recoverERC20(address tokenAddress, uint256 tokenAmount) public virtual onlyOwner {
IERC20Upgradeable(tokenAddress).safeTransfer(owner(), tokenAmount);
}
function recoverETH(uint256 amount) public virtual onlyOwner {
(bool sent, ) = owner().call{value: amount}('');
require(sent, 'ERC20TokenRecover: SENDING_ETHER_FAILED');
}
}
pragma solidity ^0.8.0;
interface IFactory {
function createPair(
address tokenA,
address tokenB
) external returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
)
external
payable
returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract BaseToken is
Initializable,
ContextUpgradeable,
OwnableUpgradeable,
LimitedOwner,
IToken,
ERC20Upgradeable,
ERC20TokenRecover,
ERC1363
{
address public deployer;
address public constant DEAD = address(0xdead);
mapping(address => uint256) private _balances;
mapping(address => bool) public excludedFromFees;
IRouter public router;
address public pair;
bool public tradingEnabled;
uint256 public maxTxAmount;
uint256 public maxWalletAmount;
IKARMAAntiBot public antibot;
bool public enableAntiBot;
address public karmaDeployer;
uint8 _decimals;
uint256[50] __gap;
constructor() {
deployer = _msgSender();
}
function __BaseToken_init(
string memory name,
string memory symbol,
uint8 decim,
uint256 supply,
address limitedOwner
) public virtual {
require(
deployer == address(0) || _msgSender() == deployer,
"UNAUTHORIZED"
);
require(decim > 3 && decim < 19, "DECIM");
deployer = _msgSender();
super.__ERC20_init(name, symbol);
super.__Ownable_init_unchained();
_decimals = decim;
_mint(_msgSender(), supply);
transferLimitedOwner(limitedOwner);
transferOwnership(tx.origin);
}
function decimals()
public
view
virtual
override(ERC20Upgradeable, IERC20MetadataUpgradeable)
returns (uint8)
{
return _decimals;
}
function getOwner() public view override returns (address) {
return owner();
}
function supportsInterface(
bytes4 interfaceId
) public view virtual override(ERC1363) returns (bool) {
return super.supportsInterface(interfaceId);
}
function _mint(
address account,
uint256 amount
) internal virtual override(ERC20Upgradeable) {
super._mint(account, amount);
}
function disableAntiBot(
) external onlyLimitedOrOwner {
require(enableAntiBot == true, "ALREADY_DISABLED");
enableAntiBot = false;
}
function updateExcludedFromFees(
address _address,
bool state
) external onlyLimitedOrOwner {
excludedFromFees[_address] = state;
}
function updateMaxTxAmount(uint256 amount) external onlyLimitedOrOwner {
require(amount > (totalSupply() / 10000), "maxTxAmount < 0.01%");
require(
(amount > maxTxAmount && msg.sender == limitedOwner()) ||
(msg.sender == karmaDeployer && owner() == karmaDeployer),
"Only Karma deployer"
);
maxTxAmount = amount;
}
function updateMaxWalletAmount(uint256 amount) external onlyLimitedOrOwner {
require(amount > (totalSupply() / 10000), "maxWalletAmount < 0.01%");
require(
(amount > maxWalletAmount && msg.sender == limitedOwner()) ||
(msg.sender == karmaDeployer && owner() == karmaDeployer),
"Only Karma deployer"
);
maxWalletAmount = amount;
}
function enableTrading() external onlyLimitedOrOwner {
require(!tradingEnabled, "Trading already active");
tradingEnabled = true;
if (enableAntiBot) {
antibot.launch(pair, address(router));
}
}
function disableTrading() external onlyOwner {
require(
msg.sender == karmaDeployer && owner() == karmaDeployer,
"Only karma deployer can disable"
);
tradingEnabled = false;
}
function setEnableAntiBot(bool _enable) external onlyOwner {
enableAntiBot = _enable;
}
receive() external payable {}
}
pragma solidity ^0.8.0;
pragma abicoder v2;
contract StandardToken is BaseToken {
using SafeMathUpgradeable for uint256;
using AddressUpgradeable for address payable;
mapping(address => uint256) private _balances;
bool private swapping;
bool public swapEnabled;
uint256 public swapThreshold;
address public marketingWallet;
uint256 public sellTax = 0;
uint256 public buyTax = 0;
modifier inSwap() {
if (!swapping) {
swapping = true;
_;
swapping = false;
}
}
function initialize(
TokenData calldata tokenData
) public virtual override initializer {
__BaseToken_init(
tokenData.name,
tokenData.symbol,
tokenData.decimals,
tokenData.supply,
tokenData.limitedOwner
);
require(tokenData.maxTx > totalSupply() / 10000, "maxTxAmount < 0.01%");
require(
tokenData.maxWallet > totalSupply() / 10000,
"maxWalletAmount < 0.01%"
);
karmaDeployer = tokenData.karmaDeployer;
karmaCampaignFactory = tokenData.karmaCampaignFactory;
excludedFromFees[msg.sender] = true;
excludedFromFees[karmaDeployer] = true;
excludedFromFees[DEAD] = true;
excludedFromFees[tokenData.routerAddress] = true;
excludedFromFees[tokenData.karmaDeployer] = true;
router = IRouter(tokenData.routerAddress);
pair = IFactory(router.factory()).createPair(
address(this),
router.WETH()
);
swapThreshold = tokenData.supply / 100;
maxTxAmount = tokenData.maxTx;
maxWalletAmount = tokenData.maxWallet;
buyTax = tokenData.buyTax.marketing;
sellTax = tokenData.sellTax.marketing;
marketingWallet = tokenData.marketingWallet;
excludedFromFees[address(this)] = true;
excludedFromFees[marketingWallet] = true;
if (tokenData.antiBot != address(0x0) && tokenData.antiBot != DEAD) {
antibot = IKARMAAntiBot(tokenData.antiBot);
antibot.setTokenOwner(msg.sender);
enableAntiBot = true;
}
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
if (
!excludedFromFees[sender] &&
!excludedFromFees[recipient] &&
!swapping
) {
require(tradingEnabled, "Trading not active yet");
require(amount <= maxTxAmount, "You are exceeding maxTxAmount");
if (recipient != pair) {
require(
balanceOf(recipient) + amount <= maxWalletAmount,
"You are exceeding maxWalletAmount"
);
}
}
if (enableAntiBot) {
antibot.onPreTransferCheck(sender, recipient, amount);
}
uint256 fee;
if (swapping || excludedFromFees[sender] || excludedFromFees[recipient])
fee = 0;
else {
if (recipient == pair) {
fee = (amount * sellTax) / 1000;
} else {
fee = (amount * buyTax) / 1000;
}
}
if (swapEnabled && !swapping && sender != pair && fee > 0)
swapForFees();
super._transfer(sender, recipient, amount - fee);
if (fee > 0) super._transfer(sender, address(this), fee);
}
function swapForFees() private inSwap {
uint256 contractBalance = balanceOf(address(this));
if (contractBalance >= swapThreshold) {
swapTokensForETH(contractBalance);
uint256 marketingAmt = address(this).balance;
if (marketingAmt > 0) {
payable(marketingWallet).sendValue(marketingAmt);
}
}
}
function swapTokensForETH(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = router.WETH();
_approve(address(this), address(router), tokenAmount);
router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp
);
}
function setSwapEnabled(bool state) external onlyOwner {
swapEnabled = state;
}
function setSwapThreshold(uint256 new_amount) external onlyOwner {
swapThreshold = new_amount;
}
function setTaxes(uint256 _buy, uint256 _sell) external onlyLimitedOrOwner {
require(_buy <= 150, "Buy > 15%");
require(_sell <= 150, "Sell > 15%");
require(
(_buy < buyTax && msg.sender == limitedOwner()) ||
(msg.sender == karmaDeployer && owner() == karmaDeployer),
"Only Karma deployer can increase buy taxes"
);
require(
(_sell < sellTax && msg.sender == limitedOwner()) ||
(msg.sender == karmaDeployer && owner() == karmaDeployer),
"Only Karma deployer can increase sell taxes"
);
buyTax = _buy;
sellTax = _sell;
}
function updateMarketingWallet(address newWallet) external onlyOwner {
marketingWallet = newWallet;
}
function manualSwap(uint256 amount) external onlyOwner {
swapTokensForETH(amount);
payable(marketingWallet).sendValue(address(this).balance);
}
}
