Contract 0x11984dc4465481512eb5b777e44061c158cf2259 12

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, 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) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or 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 {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// SPDX-License-Identifier: MIT OR Apache-2.0
pragma solidity 0.8.17;

// ============ External Imports ============
import {Address} from "@openzeppelin/contracts/utils/Address.sol";

/**
 * @title UpgradeBeacon
 * @notice Stores the address of an implementation contract
 * and allows a controller to upgrade the implementation address
 * @dev This implementation combines the gas savings of having no function selectors
 * found in 0age's implementation:
 * https://github.com/dharma-eng/dharma-smart-wallet/blob/master/contracts/proxies/smart-wallet/UpgradeBeaconProxyV1.sol
 * With the added niceties of a safety check that each implementation is a contract
 * and an Upgrade event emitted each time the implementation is changed
 * found in OpenZeppelin's implementation:
 * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/proxy/beacon/BeaconProxy.sol
 */
contract UpgradeBeacon {
  // ============ Immutables ============

  // The controller is capable of modifying the implementation address
  address private immutable controller;

  // ============ Private Storage Variables ============

  // The implementation address is held in storage slot zero.
  address private implementation;

  // ============ Events ============

  // Upgrade event is emitted each time the implementation address is set
  // (including deployment)
  event Upgrade(address indexed implementation);

  // ============ Constructor ============

  /**
   * @notice Validate the initial implementation and store it.
   * Store the controller immutably.
   * @param _initialImplementation Address of the initial implementation contract
   * @param _controller Address of the controller who can upgrade the implementation
   */
  constructor(address _initialImplementation, address _controller) payable {
    _setImplementation(_initialImplementation);
    controller = _controller;
  }

  // ============ External Functions ============

  /**
   * @notice For all callers except the controller, return the current implementation address.
   * If called by the Controller, update the implementation address
   * to the address passed in the calldata.
   * Note: this requires inline assembly because Solidity fallback functions
   * do not natively take arguments or return values.
   */
  fallback() external payable {
    if (msg.sender != controller) {
      // if not called by the controller,
      // load implementation address from storage slot zero
      // and return it.
      assembly {
        mstore(0, sload(0))
        return(0, 32)
      }
    } else {
      // if called by the controller,
      // load new implementation address from the first word of the calldata
      address _newImplementation;
      assembly {
        _newImplementation := calldataload(0)
      }
      // set the new implementation
      _setImplementation(_newImplementation);
    }
  }

  // ============ Private Functions ============

  /**
   * @notice Perform checks on the new implementation address
   * then upgrade the stored implementation.
   * @param _newImplementation Address of the new implementation contract which will replace the old one
   */
  function _setImplementation(address _newImplementation) private {
    // Require that the new implementation is different from the current one
    require(implementation != _newImplementation, "!upgrade");
    // Require that the new implementation is a contract
    require(Address.isContract(_newImplementation), "implementation !contract");
    // set the new implementation
    implementation = _newImplementation;
    emit Upgrade(_newImplementation);
  }
}

{
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs",
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [],
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_initialImplementation","type":"address"},{"internalType":"address","name":"_controller","type":"address"}],"stateMutability":"payable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgrade","type":"event"},{"stateMutability":"payable","type":"fallback"}]

60a06040526040516103283803806103288339810160408190526100229161015c565b61002b8261003d565b6001600160a01b03166080525061018f565b6000546001600160a01b0380831691160361008a5760405162461bcd60e51b8152602060048201526008602482015267217570677261646560c01b60448201526064015b60405180910390fd5b61009d8161013160201b61013a1760201c565b6100e95760405162461bcd60e51b815260206004820152601860248201527f696d706c656d656e746174696f6e2021636f6e747261637400000000000000006044820152606401610081565b600080546001600160a01b0319166001600160a01b038316908117825560405190917ff78721226efe9a1bb678189a16d1554928b9f2192e2cb93eeda83b79fa40007d91a250565b6001600160a01b03163b151590565b80516001600160a01b038116811461015757600080fd5b919050565b6000806040838503121561016f57600080fd5b61017883610140565b915061018660208401610140565b90509250929050565b60805161017f6101a96000396000600f015261017f6000f3fe6080604052336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146100405760005460005260206000f35b60003561004c8161004e565b005b6000546001600160a01b0380831691160361009b5760405162461bcd60e51b8152602060048201526008602482015267217570677261646560c01b60448201526064015b60405180910390fd5b6001600160a01b0381163b6100f25760405162461bcd60e51b815260206004820152601860248201527f696d706c656d656e746174696f6e2021636f6e747261637400000000000000006044820152606401610092565b600080546001600160a01b0319166001600160a01b038316908117825560405190917ff78721226efe9a1bb678189a16d1554928b9f2192e2cb93eeda83b79fa40007d91a250565b6001600160a01b03163b15159056fea2646970667358221220999210c314e678c37dda4571b82d6639d4e4ba3e320610d428105195d3e1603464736f6c63430008110033000000000000000000000000e9ddd1963d302d1e13239a3c25254efd39c2da91000000000000000000000000a28de94d2e6f84659c2c32df14334daa08dd6461

000000000000000000000000e9ddd1963d302d1e13239a3c25254efd39c2da91000000000000000000000000a28de94d2e6f84659c2c32df14334daa08dd6461

-----Decoded View---------------
Arg [0] : _initialImplementation (address): 0xE9ddD1963D302d1E13239A3C25254EfD39C2DA91
Arg [1] : _controller (address): 0xa28DE94d2e6F84659c2C32dF14334Daa08DD6461

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000e9ddd1963d302d1e13239a3c25254efd39c2da91
Arg [1] : 000000000000000000000000a28de94d2e6f84659c2c32df14334daa08dd6461