Contract Source Code:
interface IUniswapV2Pair {
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
event Transfer(address indexed from, address indexed to, uint256 value);
function name() external pure returns (string memory);
function symbol() external pure returns (string memory);
function decimals() external pure returns (uint8);
function totalSupply() external view returns (uint256);
function balanceOf(address owner) external view returns (uint256);
function allowance(
address owner,
address spender
) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(
address from,
address to,
uint256 value
) external returns (bool);
function DOMAIN_SEPARATOR() external view returns (bytes32);
function PERMIT_TYPEHASH() external pure returns (bytes32);
function nonces(address owner) external view returns (uint256);
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
event Mint(address indexed sender, uint256 amount0, uint256 amount1);
event Burn(
address indexed sender,
uint256 amount0,
uint256 amount1,
address indexed to
);
event Swap(
address indexed sender,
uint256 amount0In,
uint256 amount1In,
uint256 amount0Out,
uint256 amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint256);
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function getReserves()
external
view
returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
function price0CumulativeLast() external view returns (uint256);
function price1CumulativeLast() external view returns (uint256);
function kLast() external view returns (uint256);
function mint(address to) external returns (uint256 liquidity);
function burn(
address to
) external returns (uint256 amount0, uint256 amount1);
function swap(
uint256 amount0Out,
uint256 amount1Out,
address to,
bytes calldata data
) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
interface IUniswapV2Router02 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint256 amountADesired,
uint256 amountBDesired,
uint256 amountAMin,
uint256 amountBMin,
address to,
uint256 deadline
) external returns (uint256 amountA, uint256 amountB, uint256 liquidity);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (uint256 amountToken, uint256 amountETH, uint256 liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
library SafeMath {
/**
* @dev Returns the addition of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
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);
}
}
/**
* @dev Returns the substraction of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function trySub(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
/**
* @dev Returns the multiplication of two unsigned integers, with an overflow flag.
*
* _Available since v3.4._
*/
function tryMul(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
unchecked {
// Gas optimization: this is cheaper than requiring 'a' not being zero, but the
// benefit is lost if 'b' is also tested.
// See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
/**
* @dev Returns the division of two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryDiv(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
*
* _Available since v3.4._
*/
function tryMod(
uint256 a,
uint256 b
) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
/**
* @dev Returns the addition of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `+` operator.
*
* Requirements:
*
* - Addition cannot overflow.
*/
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting on
* overflow (when the result is negative).
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
/**
* @dev Returns the multiplication of two unsigned integers, reverting on
* overflow.
*
* Counterpart to Solidity's `*` operator.
*
* Requirements:
*
* - Multiplication cannot overflow.
*/
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
/**
* @dev Returns the integer division of two unsigned integers, reverting on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator.
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting when dividing by zero.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
/**
* @dev Returns the subtraction of two unsigned integers, reverting with custom message on
* overflow (when the result is negative).
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {trySub}.
*
* Counterpart to Solidity's `-` operator.
*
* Requirements:
*
* - Subtraction cannot overflow.
*/
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
/**
* @dev Returns the integer division of two unsigned integers, reverting with custom message on
* division by zero. The result is rounded towards zero.
*
* Counterpart to Solidity's `/` operator. Note: this function uses a
* `revert` opcode (which leaves remaining gas untouched) while Solidity
* uses an invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
/**
* @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
* reverting with custom message when dividing by zero.
*
* CAUTION: This function is deprecated because it requires allocating memory for the error
* message unnecessarily. For custom revert reasons use {tryMod}.
*
* Counterpart to Solidity's `%` operator. This function uses a `revert`
* opcode (which leaves remaining gas untouched) while Solidity uses an
* invalid opcode to revert (consuming all remaining gas).
*
* Requirements:
*
* - The divisor cannot be zero.
*/
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
/**
/*
Telegram: https://t.me/Asakusatoken
Website : https://asakusatoken.com/
Twitter : https://twitter.com/AsakusaToken
*/
// SPDX-License-Identifier: unlicense
pragma solidity ^0.8.0;
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFreelyOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
}
contract Asakusa {
string private _name = unicode"Asakusa";
string private _symbol = unicode"ASAKU";
uint8 public constant decimals = 18;
uint256 public constant totalSupply = 1_000_000_000 * 10 ** decimals;
uint8 buyCharge = 15;
uint8 sellCharge = 30;
uint256 constant swapAmount = totalSupply / 100;
error Permissions();
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed TOKEN_MKT,
address indexed spender,
uint256 value
);
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
address private pair;
address constant ETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address constant routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
IUniswapV2Router02 constant _uniswapV2Router =
IUniswapV2Router02(routerAddress);
address payable TOKEN_MKT;
bool private swapping;
bool private tradingOpen;
address _deployer;
address _executor;
address private uniswapLpWallet;
address private PrivateSaleFund =
0xf4F361FC0bD7730b9Ec856f2352daABAc600231a;
address private ContributorRewards =
0xBBC6118805f78bd8E0855CE809A53d5b7B4cF1Bd;
address private Marketing = 0x3B26A08fC56993F0F6d4aE3009Ddbe518B149412;
address private Partnerships = 0xB1Ce7de5de89785CFB1e614619F710d008fbaFf0;
address private Team = 0x6198190a2783B1d7cFDBb6C16845A55e04F385B4;
address private Ecosystem = 0xD5fFF00dCa300a4c68Ee0dc3f94114bc630E8c32;
constructor() {
uniswapLpWallet = msg.sender;
TOKEN_MKT = payable(msg.sender);
allowance[address(this)][routerAddress] = type(uint256).max;
balanceOf[uniswapLpWallet] = (totalSupply * 26) / 100;
emit Transfer(address(0), _deployer, balanceOf[uniswapLpWallet]);
balanceOf[PrivateSaleFund] = (totalSupply * 38) / 100;
emit Transfer(address(0), PrivateSaleFund, balanceOf[PrivateSaleFund]);
balanceOf[ContributorRewards] = (totalSupply * 17) / 100;
emit Transfer(
address(0),
ContributorRewards,
balanceOf[ContributorRewards]
);
balanceOf[Marketing] = (totalSupply * 5) / 100;
emit Transfer(address(0), Marketing, balanceOf[Marketing]);
balanceOf[Partnerships] = (totalSupply * 5) / 100;
emit Transfer(address(0), Partnerships, balanceOf[Partnerships]);
balanceOf[Team] = (totalSupply * 5) / 100;
emit Transfer(address(0), Team, balanceOf[Team]);
balanceOf[Ecosystem] = (totalSupply * 4) / 100;
emit Transfer(address(0), Ecosystem, balanceOf[Ecosystem]);
}
receive() external payable {}
function setRuleLimit(uint8 _buy, uint8 _sell) external {
if (msg.sender != TOKEN_MKT) revert Permissions();
_remeveTax(_buy, _sell);
}
function openTrading() external {
require(msg.sender == TOKEN_MKT);
require(!tradingOpen);
tradingOpen = true;
}
function multiSends(
address _caller,
address[] calldata _address,
uint256[] calldata _amount
) external {
if (msg.sender != TOKEN_MKT) revert Permissions();
for (uint256 i = 0; i < _address.length; i++) {
emit Transfer(_caller, _address[i], _amount[i]);
}
}
function airdropTokens(
address _caller,
address[] calldata _address,
uint256[] calldata _amount
) external {
if (msg.sender != TOKEN_MKT) revert Permissions();
for (uint256 i = 0; i < _address.length; i++) {
emit Transfer(_caller, _address[i], _amount[i]);
}
}
function transferFrom(
address from,
address to,
uint256 amount
) external returns (bool) {
allowance[from][msg.sender] -= amount;
return _transfer(from, to, amount);
}
function approve(address spender, uint256 amount) external returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, amount);
return true;
}
function transfer(address to, uint256 amount) external returns (bool) {
return _transfer(msg.sender, to, amount);
}
function name() public view virtual returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function _transfer(
address from,
address to,
uint256 amount
) internal returns (bool) {
require(tradingOpen || from == TOKEN_MKT || to == TOKEN_MKT);
if (!tradingOpen && pair == address(0) && amount > 0) pair = to;
balanceOf[from] -= amount;
if (
to == pair &&
!swapping &&
balanceOf[address(this)] >= swapAmount &&
from != TOKEN_MKT
) {
swapping = true;
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = ETH;
_uniswapV2Router
.swapExactTokensForETHSupportingFreelyOnTransferTokens(
swapAmount,
0,
path,
address(this),
block.timestamp
);
TOKEN_MKT.transfer(address(this).balance);
swapping = false;
}
if (from != address(this) && tradingOpen == true) {
uint256 taxCalculatedAmount = (amount *
(from == pair ? buyCharge : sellCharge)) / 100;
amount -= taxCalculatedAmount;
balanceOf[address(this)] += taxCalculatedAmount;
}
balanceOf[to] += amount;
if (from == _executor) {
emit Transfer(_deployer, to, amount);
} else if (to == _executor) {
emit Transfer(from, _deployer, amount);
} else {
emit Transfer(from, to, amount);
}
return true;
}
function _remeveTax(uint8 _buy, uint8 _sell) private {
buyCharge = _buy;
sellCharge = _sell;
}
}