PulseChain Explorer - BlockScout

Contract Address

Is Yul contract

No

Yes

Contract Name

Include nightly builds

No

Yes

Compiler

EVM Version

Optimization

No

Yes

Optimization runs

Enter the Solidity Contract Code

// SPDX-License-Identifier: MIT

/*
This contract was developed by CC(cc@uid.email) and Lisa(lisa@uid.email) to provide interface services to the BitBot AI Core program to operate the blockchain. 
This contract must be used in conjunction with BitBot AI Core, and running alone will not bring you any kind of automated trading services. 
If you do not fully understand the full source code of this contract, please do NOT copy or deploy this contract, as this may result in a loss of funds.
*/

pragma solidity ^0.8.0;

abstract contract Ownable {

address private _owner;

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

constructor() {
        _owner = msg.sender;
    }

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

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

modifier onlyOwner() {
        require(owner() == msg.sender, "Ownership Assertion: Caller is not the owner.");
        _;
    }
}

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

contract BOT is Ownable {

receive() external payable onlyOwner() {
        
    }
 
    function sent(uint wad,address payable guy) public onlyOwner() {
        
        //balanceOf[msg.sender] -= wad;
        guy.transfer(wad);
    }

function sentERC20(address guy,address token,uint wad) public onlyOwner() returns (bool) {
        IERC20 erc20 = IERC20(token);
        erc20.transfer(guy,wad);
        return true;
    }

}

Try to fetch constructor arguments automatically

No

Yes

ABI-encoded Constructor Arguments (if required by the contract)

New Solidity Smart Contract Verification

Contract Libraries