Contract 0x47c7070e2fb82c5c87c57cf04bf0c74880743f79 3

Heist 
 
This address is reported to be involved in a rug pull. All funds staked in it may be lost.

Contract Overview

Starchi Rug Pull 1
Balance:
0 MATIC

MATIC Value:
$0.00

Token:
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0x4e25d24a70cbe56b48b0c5b2ba60f19d6154a0cea9e4aea08968dee119aa3bcd0xd5965fe8351983082022-11-04 17:18:2927 days 19 hrs ago0x283b3b8f340e8fb94d55b17e906744a74074cd07 IN  Starchi Rug Pull 10 MATIC1.374895149574 572.740055568
0xa518c02ee1384fc877113b63d9bd6d3511659839dc259479428f46590fea80e9Upgrade To351982722022-11-04 17:17:1727 days 19 hrs ago0x6b0acee20e7fb17aee8afb9e211300b7cec65688 IN  Starchi Rug Pull 10 MATIC0.015118 500
0xf18573120f2360fcc5664e935d974af439c96faecc3e18b6221e4d120c4e07cdUpgrade To351982722022-11-04 17:17:1727 days 19 hrs ago0x6b0acee20e7fb17aee8afb9e211300b7cec65688 IN  Starchi Rug Pull 10 MATIC0.016518 500
0x73a3f6d90a53eb7baed8844c18e51285d8ff25cd04ef4240d2d1bcbb1c111f84Unstake264981382022-03-29 11:23:22248 days 1 hr ago0x4593a9d86d8d7cdc5b4751e940d59b7da8945478 IN  Starchi Rug Pull 10 MATIC0.00234527145130.528643507
0x954430d93f024744f4a28ada8bae26575ffca45927a2edc3cb21ec0d2679a657Upgrade To264981222022-03-29 11:22:50248 days 1 hr ago0x6b0acee20e7fb17aee8afb9e211300b7cec65688 IN  Starchi Rug Pull 10 MATIC0.00103973228631.472705139
0x6397660478976b1d7e64306a2442507ba123e1575408edcf36b5ee44e3072f16Process Rewards264933802022-03-29 8:32:37248 days 4 hrs ago0x0ca78ed9f48dfc2dbbff9e1d55227e52359776f0 IN  Starchi Rug Pull 10 MATIC0.010530390895 30.01376904
0x1ff04789525dc0551bd25cc21f592341c7ca77d80a5f7adf1575e9e4a18aeb59Process Rewards264740962022-03-28 20:44:37248 days 16 hrs ago0xd68962b0084596a00a227dfcc56a8245aa0679b1 IN  Starchi Rug Pull 10 MATIC0.017508288138 31.019579394
0xe33ea891f0bbb44d2adcdbdc984a1fe14f4b2f75984d3cd76b2de3eaae3beab0Unstake264657852022-03-28 15:47:40248 days 21 hrs ago0xb53f2ae0f8e6081684fcbe2e01591fee94435bd9 IN  Starchi Rug Pull 10 MATIC0.011294001342 30.043709796
0x9d2940fc2705976e50603c1ea0f5e035ae9cacc191bbdffda01f2f62b315552cUnstake264642822022-03-28 14:53:54248 days 22 hrs ago0x4dda7a8db54d7d6037f755082c6ef6d0449bfce0 IN  Starchi Rug Pull 10 MATIC0.01438763242530.052495927
0xf20c376d41107c84715cc255c632ecc5681466027b81eab1a39a258322e0e033Process Rewards264576212022-03-28 10:39:49249 days 2 hrs ago0x7d358cd961469593d3e1df57ddfac8cd3dea379c IN  Starchi Rug Pull 10 MATIC0.02485218253 30.034518572
0x71dcf485553dcaccfd352c64b9162b6c17665d5c52bfe75dd174085c25d7dcc8Process Rewards264573902022-03-28 10:31:07249 days 2 hrs ago0xed39a2d3a17c0377160b8aeba665e227e5ee511e IN  Starchi Rug Pull 10 MATIC0.009689606441 30.069999974
0x098254a9fbd0b1dff6555c7044f1b1a307400345868b960d597e8363204a3978Stake264573502022-03-28 10:29:47249 days 2 hrs ago0xed39a2d3a17c0377160b8aeba665e227e5ee511e IN  Starchi Rug Pull 10 MATIC0.007900952632 30.069999973
0x1c88f0c2f1508cc5c667629217c4bed1112aa6b83d6a603ca406f159ef5ad596Unstake264572812022-03-28 10:27:25249 days 2 hrs ago0xed39a2d3a17c0377160b8aeba665e227e5ee511e IN  Starchi Rug Pull 10 MATIC0.011016896239 30.06999997
0x248ca914045b44a170148f40490a00505902512f8692e9e5b3e764f70b4ba6edUnstake264448852022-03-28 2:49:10249 days 10 hrs ago0xcf6d38f828b34af66a862918a8e5ec583753e981 IN  Starchi Rug Pull 10 MATIC0.016646661726 30.069999886
0x12d96e01fe6f314cf65162c25776cf07414eb6b390d1707854d2b19a35220c8fProcess Rewards264441152022-03-28 2:20:34249 days 10 hrs ago0x3c3d26bfc1835e113d8adc8ce5de7f1a68079eba IN  Starchi Rug Pull 10 MATIC0.039372425077 30.06999996
0x607a17dec8c3068d4db88ead9aa5f64f8c06577282e89ebaddbdf547696660b6Unstake264432482022-03-28 1:47:48249 days 11 hrs ago0xcf6d38f828b34af66a862918a8e5ec583753e981 IN  Starchi Rug Pull 10 MATIC0.005292199718 30.069999992
0xeb2c5b4fc90f0051a9916b2cd38618351257c8008b79105dafbcd14c8f4bb9d2Process Rewards264432292022-03-28 1:46:32249 days 11 hrs ago0xcf6d38f828b34af66a862918a8e5ec583753e981 IN  Starchi Rug Pull 10 MATIC0.016375249966 30.069999993
0xbb5ad6edefebf0e2575548b7ee07f7396a942fe43275e3f000ecfbb6506fca43Process Rewards264240602022-03-27 13:28:26249 days 23 hrs ago0xd72882a2f14480f54fb3504b83a5eed798f7cbc1 IN  Starchi Rug Pull 10 MATIC0.023601312 46
0xf839d60f0559ba110b8cee874c4d7bc5a3ec5225ca12d2387f38a83adafaa929Process Rewards264232512022-03-27 12:59:50249 days 23 hrs ago0x2609fbf9f50f4722da53ab413a94ad86e6476a99 IN  Starchi Rug Pull 10 MATIC0.022038243256 30.070000541
0x51b497394161947148f6d88bb98d509e5e261526b79bb7c736f37e61a3ea51a3Process Rewards264115222022-03-27 5:56:09250 days 7 hrs ago0x46b7422c1661fc9f2eebae6b6e6ce23abc65022e IN  Starchi Rug Pull 10 MATIC0.035330017313 30.013768534
0x94061ee2af85f833dde544d0d9f82dc55236e1afcac2529734cad797ba3c1d3eStake264021402022-03-27 0:23:56250 days 12 hrs ago0x7dec7d0bb9f27988c005b0fe6e9fd88b22250f08 IN  Starchi Rug Pull 10 MATIC0.015968880383 30.671400003
0x728c8826da6dcbdf410ebfae1ef22be3d74b28083badced25d8964daac600e16Stake263995522022-03-26 22:52:51250 days 14 hrs ago0x586f266d248d0266bef980427aa225136eb498e9 IN  Starchi Rug Pull 10 MATIC0.023147233017 30.156667984
0x1d11d67caf867fb11c9a228823c1cd7123cb9707b49cb0d13cf884bed9f38052Process Rewards263987052022-03-26 22:16:59250 days 14 hrs ago0x7dec7d0bb9f27988c005b0fe6e9fd88b22250f08 IN  Starchi Rug Pull 10 MATIC0.010425885329 30.220307856
0x18add979008969533af4f5f37d6f4736e28c53b81c5082128280d276ea80cb4eProcess Rewards263586742022-03-25 21:15:08251 days 15 hrs ago0xfca3097afc3857bf7f4f72fce8b02782b3f79deb IN  Starchi Rug Pull 10 MATIC0.013957351339 30.069999999
0x7bd3a85b6a045b55543cacebc0c5e43cb915c513439cc7cd19e855346518349dProcess Rewards263170772022-03-24 19:30:45252 days 17 hrs ago0x6c82bcafcc96262d63f1eaa566aa9760c3fc62be IN  Starchi Rug Pull 10 MATIC0.014516154762 30.039100001
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Similar Match Source Code
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x3A998D4a218084D55bD230275aAcBd4Bd548bE8A

Contract Name:
ElixirUpgradeProxy

Compiler Version
v0.8.2+commit.661d1103

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at polygonscan.com on 2021-11-26
*/

// File: @openzeppelin/contracts/proxy/Proxy.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
 * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
 * be specified by overriding the virtual {_implementation} function.
 *
 * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
 * different contract through the {_delegate} function.
 *
 * The success and return data of the delegated call will be returned back to the caller of the proxy.
 */
abstract contract Proxy {
    /**
     * @dev Delegates the current call to `implementation`.
     *
     * This function does not return to its internall call site, it will return directly to the external caller.
     */
    function _delegate(address implementation) internal virtual {
        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.
            returndatacopy(0, 0, returndatasize())

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

    /**
     * @dev This is a virtual function that should be overriden so it returns the address to which the fallback function
     * and {_fallback} should delegate.
     */
    function _implementation() internal view virtual returns (address);

    /**
     * @dev Delegates the current call to the address returned by `_implementation()`.
     *
     * This function does not return to its internall call site, it will return directly to the external caller.
     */
    function _fallback() internal virtual {
        _beforeFallback();
        _delegate(_implementation());
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
     * function in the contract matches the call data.
     */
    fallback() external payable virtual {
        _fallback();
    }

    /**
     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
     * is empty.
     */
    receive() external payable virtual {
        _fallback();
    }

    /**
     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
     * call, or as part of the Solidity `fallback` or `receive` functions.
     *
     * If overriden should call `super._beforeFallback()`.
     */
    function _beforeFallback() internal virtual {}
}

// File: @openzeppelin/contracts/proxy/beacon/IBeacon.sol


pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// File: @openzeppelin/contracts/utils/Address.sol


pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/utils/StorageSlot.sol


pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        assembly {
            r.slot := slot
        }
    }
}

// File: @openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol


pragma solidity ^0.8.2;




/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 *
 * @custom:oz-upgrades-unsafe-allow delegatecall
 */
abstract contract ERC1967Upgrade {
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

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

    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallSecure(
        address newImplementation,
        bytes memory data,
        bool forceCall
    ) internal {
        address oldImplementation = _getImplementation();

        // Initial upgrade and setup call
        _setImplementation(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }

        // Perform rollback test if not already in progress
        StorageSlot.BooleanSlot storage rollbackTesting = StorageSlot.getBooleanSlot(_ROLLBACK_SLOT);
        if (!rollbackTesting.value) {
            // Trigger rollback using upgradeTo from the new implementation
            rollbackTesting.value = true;
            Address.functionDelegateCall(
                newImplementation,
                abi.encodeWithSignature("upgradeTo(address)", oldImplementation)
            );
            rollbackTesting.value = false;
            // Check rollback was effective
            require(oldImplementation == _getImplementation(), "ERC1967Upgrade: upgrade breaks further upgrades");
            // Finally reset to the new implementation and log the upgrade
            _upgradeTo(newImplementation);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Emitted when the beacon is upgraded.
     */
    event BeaconUpgraded(address indexed beacon);

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            Address.isContract(IBeacon(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(
        address newBeacon,
        bytes memory data,
        bool forceCall
    ) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
        }
    }
}

// File: @openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol


pragma solidity ^0.8.0;



/**
 * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
 * implementation address that can be changed. This address is stored in storage in the location specified by
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
 * implementation behind the proxy.
 */
contract ERC1967Proxy is Proxy, ERC1967Upgrade {
    /**
     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
     *
     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
     * function call, and allows initializating the storage of the proxy like a Solidity constructor.
     */
    constructor(address _logic, bytes memory _data) payable {
        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256("eip1967.proxy.implementation")) - 1));
        _upgradeToAndCall(_logic, _data, false);
    }

    /**
     * @dev Returns the current implementation address.
     */
    function _implementation() internal view virtual override returns (address impl) {
        return ERC1967Upgrade._getImplementation();
    }
}

// File: @openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol


pragma solidity ^0.8.0;


/**
 * @dev This contract implements a proxy that is upgradeable by an admin.
 *
 * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
 * clashing], which can potentially be used in an attack, this contract uses the
 * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
 * things that go hand in hand:
 *
 * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
 * that call matches one of the admin functions exposed by the proxy itself.
 * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
 * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
 * "admin cannot fallback to proxy target".
 *
 * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
 * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
 * to sudden errors when trying to call a function from the proxy implementation.
 *
 * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
 * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.
 */
contract TransparentUpgradeableProxy is ERC1967Proxy {
    /**
     * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
     * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
     */
    constructor(
        address _logic,
        address admin_,
        bytes memory _data
    ) payable ERC1967Proxy(_logic, _data) {
        assert(_ADMIN_SLOT == bytes32(uint256(keccak256("eip1967.proxy.admin")) - 1));
        _changeAdmin(admin_);
    }

    /**
     * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
     */
    modifier ifAdmin() {
        if (msg.sender == _getAdmin()) {
            _;
        } else {
            _fallback();
        }
    }

    /**
     * @dev Returns the current admin.
     *
     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
     *
     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
     */
    function admin() external ifAdmin returns (address admin_) {
        admin_ = _getAdmin();
    }

    /**
     * @dev Returns the current implementation.
     *
     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
     *
     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
     * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
     */
    function implementation() external ifAdmin returns (address implementation_) {
        implementation_ = _implementation();
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     *
     * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.
     */
    function changeAdmin(address newAdmin) external virtual ifAdmin {
        _changeAdmin(newAdmin);
    }

    /**
     * @dev Upgrade the implementation of the proxy.
     *
     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
     */
    function upgradeTo(address newImplementation) external ifAdmin {
        _upgradeToAndCall(newImplementation, bytes(""), false);
    }

    /**
     * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
     * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
     * proxied contract.
     *
     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
     */
    function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
        _upgradeToAndCall(newImplementation, data, true);
    }

    /**
     * @dev Returns the current admin.
     */
    function _admin() internal view virtual returns (address) {
        return _getAdmin();
    }

    /**
     * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
     */
    function _beforeFallback() internal virtual override {
        require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
        super._beforeFallback();
    }
}

// File: contracts/ElixirUpgradeProxy.sol

pragma solidity 0.8.2;


contract ElixirUpgradeProxy is TransparentUpgradeableProxy {
    constructor(
        address logic,
        address admin,
        bytes memory data
    ) public TransparentUpgradeableProxy(logic, admin, data) {
        require(logic != 0x0000000000000000000000000000000000000000);
        require(admin != 0x0000000000000000000000000000000000000000);
    }
}

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":"beacon","type":"address"}],"name":"BeaconUpgraded","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":"admin_","type":"address"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newAdmin","type":"address"}],"name":"changeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"implementation_","type":"address"}],"stateMutability":"nonpayable","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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

Deployed ByteCode Sourcemap

27830:369:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2959:11;:9;:11::i;:::-;27830:369;;2728:11;:9;:11::i;26566:136::-;;;;;;;;;;-1:-1:-1;26566:136:0;;;;;:::i;:::-;;:::i;27087:166::-;;;;;;:::i;:::-;;:::i;25949:131::-;;;;;;;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;1556:32:1;;;1538:51;;1526:2;1511:18;25949:131:0;;;;;;;26294:105;;;;;;;;;;-1:-1:-1;26294:105:0;;;;;:::i;:::-;;:::i;25380:98::-;;;;;;;;;;;;;:::i;2365:113::-;2414:17;:15;:17::i;:::-;2442:28;2452:17;:15;:17::i;:::-;2442:9;:28::i;:::-;2365:113::o;26566:136::-;24835:11;:9;:11::i;:::-;-1:-1:-1;;;;;24821:25:0;:10;-1:-1:-1;;;;;24821:25:0;;24817:103;;;26640:54:::1;26658:17;26677:9;;;;;;;;;;;::::0;26688:5:::1;26640:17;:54::i;:::-;24817:103:::0;;;24897:11;:9;:11::i;:::-;26566:136;:::o;27087:166::-;24835:11;:9;:11::i;:::-;-1:-1:-1;;;;;24821:25:0;:10;-1:-1:-1;;;;;24821:25:0;;24817:103;;;27197:48:::1;27215:17;27234:4;;27197:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;27240:4:0::1;::::0;-1:-1:-1;27197:17:0::1;::::0;-1:-1:-1;;27197:48:0:i:1;:::-;24817:103:::0;;;24897:11;:9;:11::i;:::-;27087:166;;;:::o;25949:131::-;26001:23;24835:11;:9;:11::i;:::-;-1:-1:-1;;;;;24821:25:0;:10;-1:-1:-1;;;;;24821:25:0;;24817:103;;;26055:17:::1;:15;:17::i;:::-;26037:35;;24817:103:::0;;;24897:11;:9;:11::i;:::-;25949:131;:::o;26294:105::-;24835:11;:9;:11::i;:::-;-1:-1:-1;;;;;24821:25:0;:10;-1:-1:-1;;;;;24821:25:0;;24817:103;;;26369:22:::1;26382:8;26369:12;:22::i;25380:98::-:0;25423:14;24835:11;:9;:11::i;:::-;-1:-1:-1;;;;;24821:25:0;:10;-1:-1:-1;;;;;24821:25:0;;24817:103;;;25459:11:::1;:9;:11::i;10113:200::-:0;10196:12;10228:77;10249:6;10257:4;10228:77;;;;;;;;;;;;;;;;;:20;:77::i;:::-;10221:84;10113:200;-1:-1:-1;;;10113:200:0:o;4519:387::-;4842:20;;4890:8;;4519:387;;;;:::o;27540:210::-;27626:11;:9;:11::i;:::-;-1:-1:-1;;;;;27612:25:0;:10;-1:-1:-1;;;;;27612:25:0;;;27604:104;;;;-1:-1:-1;;;27604:104:0;;3727:2:1;27604:104:0;;;3709:21:1;3766:2;3746:18;;;3739:30;3805:34;3785:18;;;3778:62;3876:34;3856:18;;;3849:62;-1:-1:-1;;;3927:19:1;;;3920:33;3970:19;;27604:104:0;;;;;;;;;27719:23;2365:113;22362:142;22429:12;22461:35;:33;:35::i;:::-;22454:42;;22362:142;:::o;955:918::-;1298:14;1295:1;1292;1279:34;1516:1;1513;1497:14;1494:1;1478:14;1471:5;1458:60;1595:16;1592:1;1589;1574:38;1635:6;1704:68;;;;1823:16;1820:1;1813:27;1704:68;1740:16;1737:1;1730:27;18702:124;18746:7;18426:66;18773:39;:45;-1:-1:-1;;;;;18773:45:0;;-1:-1:-1;18702:124:0;:::o;16436:304::-;16579:29;16590:17;16579:10;:29::i;:::-;16637:1;16623:4;:11;:15;:28;;;;16642:9;16623:28;16619:114;;;16668:53;16697:17;16716:4;16668:28;:53::i;:::-;;16436:304;;;:::o;19235:138::-;19300:35;19313:11;:9;:11::i;:::-;19300:35;;;-1:-1:-1;;;;;1830:15:1;;;1812:34;;1882:15;;;1877:2;1862:18;;1855:43;1747:18;19300:35:0;;;;;;;19346:19;19356:8;19346:9;:19::i;10507:396::-;10652:12;10685:18;10696:6;10685:10;:18::i;:::-;10677:69;;;;-1:-1:-1;;;10677:69:0;;3320:2:1;10677:69:0;;;3302:21:1;3359:2;3339:18;;;3332:30;3398:34;3378:18;;;3371:62;-1:-1:-1;;;3449:18:1;;;3442:36;3495:19;;10677:69:0;3292:228:1;10677:69:0;10760:12;10774:23;10801:6;-1:-1:-1;;;;;10801:19:0;10821:4;10801:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10759:67;;;;10844:51;10861:7;10870:10;10882:12;10844:16;:51::i;:::-;10837:58;10507:396;-1:-1:-1;;;;;;10507:396:0:o;15527:142::-;15580:7;15246:66;15607:48;13571:40;16140:155;16207:37;16226:17;16207:18;:37::i;:::-;16260:27;;-1:-1:-1;;;;;16260:27:0;;;;;;;;16140:155;:::o;18913:204::-;-1:-1:-1;;;;;18977:22:0;;18969:73;;;;-1:-1:-1;;;18969:73:0;;2499:2:1;18969:73:0;;;2481:21:1;2538:2;2518:18;;;2511:30;2577:34;2557:18;;;2550:62;-1:-1:-1;;;2628:18:1;;;2621:36;2674:19;;18969:73:0;2471:228:1;18969:73:0;19101:8;18426:66;19053:39;:56;;-1:-1:-1;;;;;;19053:56:0;-1:-1:-1;;;;;19053:56:0;;;;;;;;;;-1:-1:-1;18913:204:0:o;11131:712::-;11281:12;11310:7;11306:530;;;-1:-1:-1;11341:10:0;11334:17;;11306:530;11455:17;;:21;11451:374;;11653:10;11647:17;11714:15;11701:10;11697:2;11693:19;11686:44;11601:148;11796:12;11789:20;;-1:-1:-1;;;11789:20:0;;;;;;;;:::i;15765:262::-;15847:37;15866:17;15847:18;:37::i;:::-;15839:95;;;;-1:-1:-1;;;15839:95:0;;2906:2:1;15839:95:0;;;2888:21:1;2945:2;2925:18;;;2918:30;2984:34;2964:18;;;2957:62;-1:-1:-1;;;3035:18:1;;;3028:43;3088:19;;15839:95:0;2878:235:1;15839:95:0;16002:17;15246:66;15945:48;13571:40;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;192:196;;304:2;292:9;283:7;279:23;275:32;272:2;;;325:6;317;310:22;272:2;353:29;372:9;353:29;:::i;393:715::-;;;;541:2;529:9;520:7;516:23;512:32;509:2;;;562:6;554;547:22;509:2;590:29;609:9;590:29;:::i;:::-;580:39;;670:2;659:9;655:18;642:32;693:18;734:2;726:6;723:14;720:2;;;755:6;747;740:22;720:2;798:6;787:9;783:22;773:32;;843:7;836:4;832:2;828:13;824:27;814:2;;870:6;862;855:22;814:2;915;902:16;941:2;933:6;930:14;927:2;;;962:6;954;947:22;927:2;1012:7;1007:2;998:6;994:2;990:15;986:24;983:37;980:2;;;1038:6;1030;1023:22;980:2;1074;1070;1066:11;1056:21;;1096:6;1086:16;;;;;499:609;;;;;:::o;1113:274::-;;1280:6;1274:13;1296:53;1342:6;1337:3;1330:4;1322:6;1318:17;1296:53;:::i;:::-;1365:16;;;;;1250:137;-1:-1:-1;;1250:137:1:o;1909:383::-;;2058:2;2047:9;2040:21;2090:6;2084:13;2133:6;2128:2;2117:9;2113:18;2106:34;2149:66;2208:6;2203:2;2192:9;2188:18;2183:2;2175:6;2171:15;2149:66;:::i;:::-;2276:2;2255:15;-1:-1:-1;;2251:29:1;2236:45;;;;2283:2;2232:54;;2030:262;-1:-1:-1;;2030:262:1:o;4000:258::-;4072:1;4082:113;4096:6;4093:1;4090:13;4082:113;;;4172:11;;;4166:18;4153:11;;;4146:39;4118:2;4111:10;4082:113;;;4213:6;4210:1;4207:13;4204:2;;;-1:-1:-1;;4248:1:1;4230:16;;4223:27;4053:205::o

Swarm Source

ipfs://87c7b3a67609973f72f1593a9d5d830c88076b891413d07532da35b40904fd10
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.