Token ElonGoat

MEME 
 

Overview [ERC-20]

Price
$0.00 @ 0.000000 Eth (-3.07%)
Fully Diluted Market Cap
Max Total Supply:
9,000,000,000 EGT

Holders:
4,479

Transfers:
-

 
Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

OVERVIEW

$EGT has positioned itself to become a 0% tax Token; directionally funded and accelerated by a suite of adoption focused technologies that provide expanded utility.

Market

Volume (24H):$5,118.73
Market Capitalization:$0.00
Circulating Supply:0.00 EGT
Market Data Source: Coinmarketcap

# Exchange Pair Price  24H Volume % Volume
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
TransparentUpgradeableProxyImplementation

Compiler Version
v0.8.12+commit.f00d7308

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license
/**
 *Submitted for verification at Etherscan.io on 2022-09-22
*/

pragma solidity ^0.8.12;

//SPDX-License-Identifier: MIT

/**
 * @title Proxy
 * @dev Implements delegation of calls to other contracts, with proper
 * forwarding of return values and bubbling of failures.
 * It defines a fallback function that delegates all calls to the address
 * returned by the abstract _implementation() internal function.
 */
abstract contract Proxy {
    /**
     * @dev Fallback function.
     * Implemented entirely in `_fallback`.
     */
    fallback() external payable {
        _fallback();
    }

    receive() external payable {
        _fallback();
    }

    /**
     * @return The Address of the implementation.
     */
    function _implementation() internal view virtual returns (address);

    /**
     * @dev Delegates execution to an implementation contract.
     * This is a low level function that doesn't return to its internal call site.
     * It will return to the external caller whatever the implementation returns.
     * @param implementation Address to delegate.
     */
    function _delegate(address implementation) internal {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(
                gas(),
                implementation,
                0,
                calldatasize(),
                0,
                0
            )
            // Copy the returned data.
            let retSz := returndatasize()
            returndatacopy(0, 0, retSz)

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                revert(0, retSz)
            }
            default {
                return(0, retSz)
            }
        }
    }

    /**
     * @dev Function that is run as the first thing in the fallback function.
     * Can be redefined in derived contracts to add functionality.
     * Redefinitions must call super._beforeFallback().
     */
    function _beforeFallback() internal virtual {}

    /**
     * @dev fallback implementation.
     * Extracted to enable manual triggering.
     */
    function _fallback() internal {
        _beforeFallback();
        _delegate(_implementation());
    }
}

/**
 * Utility library of inline functions on addresses
 *
 * Source https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-solidity/v2.1.3/contracts/utils/Address.sol
 * This contract is copied here and renamed from the original to avoid clashes in the compiled artifacts
 * when the user imports a zos-lib contract (that transitively causes this contract to be compiled and added to the
 * build/artifacts folder) as well as the vanilla Address implementation from an openzeppelin version.
 */
library ZOSLibAddress {
    /**
     * Returns whether the target address is a contract
     * @dev This function will return false if invoked during the constructor of a contract,
     * as the code is not actually created until after the constructor finishes.
     * @param account address of the account to check
     * @return whether the target address is a contract
     */
    function isContract(address account) internal view returns (bool) {
        uint256 size;
        // XXX Currently there is no better way to check if there is a contract in an address
        // than to check the size of the code at that address.
        // See https://ethereum.stackexchange.com/a/14016/36603
        // for more details about how this works.
        // TODO Check this again before the Serenity release, because all addresses will be
        // contracts then.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }
}

/**
 * @title BaseUpgradeabilityProxy
 * @dev This contract implements a proxy that allows to change the
 * implementation address to which it will delegate.
 * Such a change is called an implementation upgrade.
 */
contract BaseUpgradeabilityProxy is Proxy {
    /**
     * @dev Emitted when the implementation is upgraded.
     * @param implementation Address of the new implementation.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation", and is
     * validated in the constructor.
     */
    bytes32 internal constant IMPLEMENTATION_SLOT =
        0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Returns the current implementation.
     * @return impl Address of the current implementation
     */
    function _implementation() internal view override returns (address impl) {
        bytes32 slot = IMPLEMENTATION_SLOT;
        assembly {
            impl := sload(slot)
        }
    }

    /**
     * @dev Upgrades the proxy to a new implementation.
     * @param newImplementation Address of the new implementation.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Sets the implementation address of the proxy.
     * @param newImplementation Address of the new implementation.
     */
    function _setImplementation(address newImplementation) internal {
        require(
            ZOSLibAddress.isContract(newImplementation),
            "Cannot set a proxy implementation to a non-contract address"
        );

        bytes32 slot = IMPLEMENTATION_SLOT;

        assembly {
            sstore(slot, newImplementation)
        }
    }
}


/**
 * @title BaseAdminUpgradeabilityProxy
 * @dev This contract combines an upgradeability proxy with an authorization
 * mechanism for administrative tasks.
 * All external functions in this contract must be guarded by the
 * `ifAdmin` modifier. See ethereum/solidity#3864 for a Solidity
 * feature proposal that would enable this to be done automatically.
 */
contract TransparentUpgradeableProxy is BaseUpgradeabilityProxy {
    //ERC-1967 bytes32(uint256(keccak256('eip1967.proxy.admin')) - 1)
    bytes32 internal constant ADMIN_SLOT =
        0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Contract constructor.
     * @param logic Address of the initial implementation.
     * @param newAdmin Admin of the proxy contract
     * @param data Data to send as msg.data to the implementation to initialize the proxied contract.
     * It should include the signature and the parameters of the function to be called, as described in
     * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
     * This parameter is optional, if no data is given the initialization call to proxied contract will be skipped.
     */
    constructor(address logic, address newAdmin, bytes memory data) payable {
        assert(IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
        assert(ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
        _setAdmin(newAdmin);
        _setImplementation(logic);
        if (data.length > 0) {
            (bool success, ) = logic.delegatecall(data);
            require(success);
        }
    }

    /**
     * @dev Emitted when the administration has been transferred.
     * @param previousAdmin Address of the previous admin.
     * @param newAdmin Address of the new admin.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Modifier to check whether the `msg.sender` is the admin.
     * If it is, it will run the function. Otherwise, it will delegate the call
     * to the implementation.
     */
    modifier ifAdmin() {
        if (msg.sender == _admin()) {
            _;
        } else {
            _fallback();
        }
    }

    /**
     * @return The address of the proxy admin.
     */
    // function admin() external ifAdmin returns (address) { TODO
    function admin() external view returns (address) {
        return _admin();
    }

    /**
     * @return The address of the implementation.
     */
    // function implementation() external ifAdmin returns (address) { TODO
    function implementation() external view returns (address) {
        return _implementation();
    }

    /**
     * @dev Changes the admin of the proxy.
     * Only the current admin can call this function.
     * @param newAdmin Address to transfer proxy administration to.
     */
    function changeAdmin(address newAdmin) external ifAdmin {
        require(
            newAdmin != address(0),
            "Cannot change the admin of a proxy to the zero address"
        );
        emit AdminChanged(_admin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev Upgrade the backing implementation of the proxy.
     * Only the admin can call this function.
     * @param newImplementation Address of the new implementation.
     */
    function upgradeTo(address newImplementation) external ifAdmin {
        _upgradeTo(newImplementation);
    }

    /**
     * @dev Upgrade the backing implementation of the proxy and call a function
     * on the new implementation.
     * This is useful to initialize the proxied contract.
     * @param newImplementation Address of the new implementation.
     * @param data Data to send as msg.data in the low level call.
     * It should include the signature and the parameters of the function to be called, as described in
     * https://solidity.readthedocs.io/en/v0.4.24/abi-spec.html#function-selector-and-argument-encoding.
     */
    function upgradeToAndCall(address newImplementation, bytes calldata data)
        external
        payable
        ifAdmin
    {
        _upgradeTo(newImplementation);
        (bool success, ) = newImplementation.delegatecall(data);
        require(success);
    }

    /**
     * @return adm The admin slot.
     */
    function _admin() internal view returns (address adm) {
        bytes32 slot = ADMIN_SLOT;
        assembly {
            adm := sload(slot)
        }
    }

    /**
     * @dev Sets the address of the proxy admin.
     * @param newAdmin Address of the new proxy admin.
     */
    function _setAdmin(address newAdmin) internal {
        bytes32 slot = ADMIN_SLOT;

        assembly {
            sstore(slot, newAdmin)
        }
    }

    /**
     * @dev Only fall back when the sender is not the admin.
     */
    function _beforeFallback() internal override {
        require(
            msg.sender != _admin(),
            "Cannot call fallback function from the proxy admin"
        );
        super._beforeFallback();
    }
}

contract TransparentUpgradeableProxyImplementation is TransparentUpgradeableProxy {
    
    constructor(address logic, address admin, bytes memory data) TransparentUpgradeableProxy(logic, admin, data) {

    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"address","name":"logic","type":"address"},{"internalType":"address","name":"admin","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"changeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000004081916cfc32d699b93e86efd1cef581f53482d1000000000000000000000000ada8874a3765a5e4bb5c15f76d3de4c4971b6dd7000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000048129fc1c00000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : logic (address): 0x4081916cFC32d699b93e86eFD1CeF581F53482d1
Arg [1] : admin (address): 0xada8874a3765A5e4bb5C15f76D3dE4C4971B6DD7
Arg [2] : data (bytes): 0x8129fc1c

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000004081916cfc32d699b93e86efd1cef581f53482d1
Arg [1] : 000000000000000000000000ada8874a3765a5e4bb5c15f76d3de4c4971b6dd7
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [4] : 8129fc1c00000000000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

11328:217:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;590:11;:9;:11::i;:::-;11328:217;;525:11;:9;:11::i;9568:111::-;;;;;;;;;;-1:-1:-1;9568:111:0;;;;;:::i;:::-;;:::i;10227:272::-;;;;;;:::i;:::-;;:::i;8790:101::-;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;1217:32:1;;;1199:51;;1187:2;1172:18;8790:101:0;;;;;;;9086:279;;;;;;;;;;-1:-1:-1;9086:279:0;;;;;:::i;:::-;;:::i;8554:83::-;;;;;;;;;;;;;:::i;2483:105::-;2524:17;:15;:17::i;:::-;2552:28;2562:17;4884:66;5246:11;;5085:190;2562:17;2552:9;:28::i;:::-;2483:105::o;9568:111::-;-1:-1:-1;;;;;;;;;;;10693:11:0;-1:-1:-1;;;;;8310:22:0;:10;-1:-1:-1;;;;;8310:22:0;;8306:100;;;9642:29:::1;9653:17;9642:10;:29::i;:::-;9568:111:::0;:::o;8306:100::-;8383:11;:9;:11::i;10227:272::-;-1:-1:-1;;;;;;;;;;;10693:11:0;-1:-1:-1;;;;;8310:22:0;:10;-1:-1:-1;;;;;8310:22:0;;8306:100;;;10369:29:::1;10380:17;10369:10;:29::i;:::-;10410:12;10428:17;-1:-1:-1::0;;;;;10428:30:0::1;10459:4;;10428:36;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10409:55;;;10483:7;10475:16;;;::::0;::::1;;10358:141;10227:272:::0;;;:::o;8306:100::-;8383:11;:9;:11::i;:::-;10227:272;;;:::o;8790:101::-;8839:7;8866:17;4884:66;5246:11;;5085:190;8866:17;8859:24;;8790:101;:::o;9086:279::-;-1:-1:-1;;;;;;;;;;;10693:11:0;-1:-1:-1;;;;;8310:22:0;:10;-1:-1:-1;;;;;8310:22:0;;8306:100;;;-1:-1:-1;;;;;9175:22:0;::::1;9153:126;;;::::0;-1:-1:-1;;;9153:126:0;;1739:2:1;9153:126:0::1;::::0;::::1;1721:21:1::0;1778:2;1758:18;;;1751:30;1817:34;1797:18;;;1790:62;-1:-1:-1;;;1868:18:1;;;1861:52;1930:19;;9153:126:0::1;;;;;;;;;9295:32;9308:8;-1:-1:-1::0;;;;;;;;;;;10693:11:0;;10561:161;9308:8:::1;9295:32;::::0;;-1:-1:-1;;;;;2190:15:1;;;2172:34;;2242:15;;;2237:2;2222:18;;2215:43;2107:18;9295:32:0::1;;;;;;;9338:19;9348:8;-1:-1:-1::0;;;;;;;;;;;10973:22:0;10854:159;8554:83;8594:7;8621:8;-1:-1:-1;;;;;;;;;;;10693:11:0;;10561:161;3496:649;4081:20;4129:8;;;3496:649::o;11101:220::-;-1:-1:-1;;;;;;;;;;;10693:11:0;-1:-1:-1;;;;;11179:22:0;:10;-1:-1:-1;;;;;11179:22:0;;;11157:122;;;;-1:-1:-1;;;11157:122:0;;2471:2:1;11157:122:0;;;2453:21:1;2510:2;2490:18;;;2483:30;2549:34;2529:18;;;2522:62;-1:-1:-1;;;2600:18:1;;;2593:48;2658:19;;11157:122:0;2269:414:1;1061:1035:0;1396:14;1393:1;1390;1377:34;1717:1;1697;1664:14;1644:1;1611:14;1587:5;1556:177;1800:16;1851:5;1848:1;1845;1830:27;1880:6;1949:57;;;;2057:5;2054:1;2047:16;1949:57;1985:5;1982:1;1975:16;5426:155;5493:37;5512:17;5493:18;:37::i;:::-;5546:27;;-1:-1:-1;;;;;5546:27:0;;;;;;;;5426:155;:::o;5734:360::-;4081:20;;5809:152;;;;-1:-1:-1;;;5809:152:0;;2890:2:1;5809:152:0;;;2872:21:1;2929:2;2909:18;;;2902:30;2968:34;2948:18;;;2941:62;3039:29;3019:18;;;3012:57;3086:19;;5809:152:0;2688:423:1;5809:152:0;4884:66;6045:31;5734:360::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;:::-;333:39;192:186;-1:-1:-1;;;192:186:1:o;383:665::-;462:6;470;478;531:2;519:9;510:7;506:23;502:32;499:52;;;547:1;544;537:12;499:52;570:29;589:9;570:29;:::i;:::-;560:39;;650:2;639:9;635:18;622:32;673:18;714:2;706:6;703:14;700:34;;;730:1;727;720:12;700:34;768:6;757:9;753:22;743:32;;813:7;806:4;802:2;798:13;794:27;784:55;;835:1;832;825:12;784:55;875:2;862:16;901:2;893:6;890:14;887:34;;;917:1;914;907:12;887:34;962:7;957:2;948:6;944:2;940:15;936:24;933:37;930:57;;;983:1;980;973:12;930:57;1014:2;1010;1006:11;996:21;;1036:6;1026:16;;;;;383:665;;;;;:::o;1261:271::-;1444:6;1436;1431:3;1418:33;1400:3;1470:16;;1495:13;;;1470:16;1261:271;-1:-1:-1;1261:271:1:o

Swarm Source

ipfs://ced502f91a34577306a1cc88e703c4ae2590c939b47c8c1fefece759851abce3

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.