json.json

{
  "language": "Solidity",
  "sources": {
    "src/Raffle.sol": {
      "content": "\n\n// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.19;\n\nimport {VRFConsumerBaseV2Plus} from \"@chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol\";\n\n// import {VRFV2PlusClient} from \"@chainlink/contracts/src/v0.8/dev/vrf/libraries/VRFV2PlusClient.sol\";\nimport {VRFV2PlusClient} from \"@chainlink/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol\";\n\n/**\n * @title  A Sample Raffle Contract\n * @author  LegendaryCode\n * @notice  This contract is for creating a sample raffle\n * @dev     Implements Chainlink  VRFv2.5\n */\n\ncontract Raffle is VRFConsumerBaseV2Plus {\n   \n    /*** Errors */\n    error Raffle__SendMoreEThToEnterRaffle();\n    error Raffle__TransferFailed();\n    error Raffle__RaffleNotOpen();\n    error Raffle__UpKeepNotNeeded(uint256 balance, uint256 playersLength, uint256 raffleState);\n\n\n    /** Type Declarations */\n    enum RaffleState {\n        OPEN,      // 0\n        CALCULATING  // 1\n    }\n\n\n\n    /** State Variables */\n    uint16 private constant REQUEST_CONFIRMATIONS = 3;\n    uint32 private constant NUM_WORDS = 1;\n    uint256 private immutable i_entranceFee;\n    uint256 private immutable i_interval;\n    bytes32 private immutable i_keyHash;\n    uint256 private immutable i_subscriptionId;\n    uint32 private immutable i_callbackGasLimit;\n    address payable[] private s_players;\n\n    /// @dev The duration of the lottery in seconds.\n    uint256 private s_lastTimeStamp;\n\n    address private s_recentWinner;\n\n    /// @notice The lottery will start as OPEN\n    RaffleState private s_raffleState;  \n\n\n    /** Events */\n    event RaffleEntered(address indexed player);\n    event WinnerPicked(address indexed winner);\n    event RequestedRaffleWinner(uint256 indexed requestId);\n\n\n    /// @notice The \"constructor\" runs once when the contract is deployed. It sets up the initial states.\n    constructor(\n        uint256 entranceFee,\n        uint256 interval,\n        address vrfCoordinator,\n        bytes32 gasLane,\n        uint256 subscriptionId,\n        uint32 callbackGasLimit\n    ) VRFConsumerBaseV2Plus(vrfCoordinator) {\n        i_entranceFee = entranceFee;\n        i_interval = interval;\n        i_keyHash = gasLane;\n        i_subscriptionId = subscriptionId;\n        i_callbackGasLimit = callbackGasLimit;\n\n        s_lastTimeStamp = block.timestamp; /// @notice Initial Timestamp\n        s_raffleState = RaffleState.OPEN; /// @notice Initial Raffle State\n    }\n\n\n\n    /** Functions */\n    function enterRaffle() external payable {\n        if (msg.value < i_entranceFee) {\n            revert Raffle__SendMoreEThToEnterRaffle();\n        }\n\n        if(s_raffleState != RaffleState.OPEN){\n            revert Raffle__RaffleNotOpen();\n        }\n\n        s_players.push(payable(msg.sender));\n        emit RaffleEntered(msg.sender);\n    }\n\n   /// @notice When should the winner be picked ?\n   /**\n    * @dev This is the function that the chainlink nodes will call to see\n     * if the lottery is ready to have a winner picked.\n     * The following should be true in order for upKeepNeeded to be true.\n     * 1. The time interval has passed between raffle runs.\n     * 2. The lottery is open.\n     * 3. The contract has ETH.\n     * 4. Your subscription has LINK.\n    * @param - ignored \n    * @return upkeepNeeded - true if it's time to restart the lottery.\n    * @return - ignored\n    */\n\n    function checkUpkeep(bytes memory /* checkData */) \n        public view \n        returns(bool upkeepNeeded, bytes memory /* performData */)\n    {\n        bool timeHasPassed =  ((block.timestamp - s_lastTimeStamp) >=  i_interval);\n        bool isOpen =  s_raffleState == RaffleState.OPEN;\n        bool hasBalance = address(this).balance > 0;\n        bool hasPlayers = s_players.length > 0;\n        upkeepNeeded = timeHasPassed && isOpen && hasBalance && hasPlayers;\n        return (upkeepNeeded, \"\");\n    }\n\n\n    /// @notice perform() function 3. Be able to do this all time , automatically.\n    function performUpkeep(bytes calldata /* performData */) \n        external \n    {\n        (bool upkeepNeeded,) =  checkUpkeep(\"\");\n        if(!upkeepNeeded){\n           revert Raffle__UpKeepNotNeeded(address(this).balance, s_players.length, uint256(s_raffleState));\n        }\n\n       \n\n        //s_raffleState = RaffleState.CALCULATING; THIS IS TO PREVENT ANYONE FROM ENTERING THE RAFFLE WHILE WE ARE CALCULATING THE WINNER\n        s_raffleState = RaffleState.CALCULATING;\n        VRFV2PlusClient.RandomWordsRequest memory request = VRFV2PlusClient.RandomWordsRequest({\n            keyHash: i_keyHash,\n            subId: i_subscriptionId,\n            requestConfirmations: REQUEST_CONFIRMATIONS,\n            callbackGasLimit: i_callbackGasLimit,\n            numWords: NUM_WORDS,\n            extraArgs: VRFV2PlusClient._argsToBytes(\n                // Set nativePayment to true to pay for VRF requests with Sepolia ETH instead of LINK\n                VRFV2PlusClient.ExtraArgsV1({nativePayment: false})\n            )\n        });\n        uint256 requestId = s_vrfCoordinator.requestRandomWords(request);\n        emit RequestedRaffleWinner(requestId);\n    }\n\n\n    function fulfillRandomWords(uint256 /*requestId*/, uint256[] calldata randomWords) internal override {\n        // CHECKS (Validate the inputs and conditions to ensure that the function can execute successfully)\n\n        \n        // Effect (Updating the state of the contract) - Internal Contract State\n        uint256 indexOfWinner = randomWords[0] % s_players.length;\n        address payable recentWinner = s_players[indexOfWinner];\n        s_recentWinner = recentWinner;\n\n        s_raffleState = RaffleState.OPEN;\n        s_players = new address payable[](0);\n        s_lastTimeStamp = block.timestamp;\n\n        emit WinnerPicked(s_recentWinner);\n        \n        // Interactions (External Contract Interactions)\n        (bool success, ) = recentWinner.call{value: address(this).balance}(\"\");\n        if(!success) {\n            revert Raffle__TransferFailed();\n        }\n    }\n\n    /// @notice Getter function for i_entranceFee (since it made private)\n    function getEntranceFee() external view returns (uint256) {\n        return i_entranceFee;\n    }\n\n    /// @notice Getter function for RaffleState (since it made private)\n    function getRaffleState() external view returns (RaffleState ) {\n        return s_raffleState;\n    }\n\n    /// @notice Getter function for getPlayers Array. To be able to get players\n    function getPlayer(uint256 indexOfPlayer) external view returns(address) {\n        return s_players[indexOfPlayer];\n    }\n\n    function getLastTimeStamp() external view returns(uint256){\n        return s_lastTimeStamp;\n    }\n\n    /// @notice Getter function for getRecentWinner  function.\n    function getRecentWinner() external view returns(address){\n        return s_recentWinner;\n    }\n\n}\n"
    },
    "lib/chainlink-brownie-contracts/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\nimport {IVRFCoordinatorV2Plus} from \"./interfaces/IVRFCoordinatorV2Plus.sol\";\nimport {IVRFMigratableConsumerV2Plus} from \"./interfaces/IVRFMigratableConsumerV2Plus.sol\";\nimport {ConfirmedOwner} from \"../../shared/access/ConfirmedOwner.sol\";\n\n/** ****************************************************************************\n * @notice Interface for contracts using VRF randomness\n * *****************************************************************************\n * @dev PURPOSE\n *\n * @dev Reggie the Random Oracle (not his real job) wants to provide randomness\n * @dev to Vera the verifier in such a way that Vera can be sure he's not\n * @dev making his output up to suit himself. Reggie provides Vera a public key\n * @dev to which he knows the secret key. Each time Vera provides a seed to\n * @dev Reggie, he gives back a value which is computed completely\n * @dev deterministically from the seed and the secret key.\n *\n * @dev Reggie provides a proof by which Vera can verify that the output was\n * @dev correctly computed once Reggie tells it to her, but without that proof,\n * @dev the output is indistinguishable to her from a uniform random sample\n * @dev from the output space.\n *\n * @dev The purpose of this contract is to make it easy for unrelated contracts\n * @dev to talk to Vera the verifier about the work Reggie is doing, to provide\n * @dev simple access to a verifiable source of randomness. It ensures 2 things:\n * @dev 1. The fulfillment came from the VRFCoordinatorV2Plus.\n * @dev 2. The consumer contract implements fulfillRandomWords.\n * *****************************************************************************\n * @dev USAGE\n *\n * @dev Calling contracts must inherit from VRFConsumerBaseV2Plus, and can\n * @dev initialize VRFConsumerBaseV2Plus's attributes in their constructor as\n * @dev shown:\n *\n * @dev   contract VRFConsumerV2Plus is VRFConsumerBaseV2Plus {\n * @dev     constructor(<other arguments>, address _vrfCoordinator, address _subOwner)\n * @dev       VRFConsumerBaseV2Plus(_vrfCoordinator, _subOwner) public {\n * @dev         <initialization with other arguments goes here>\n * @dev       }\n * @dev   }\n *\n * @dev The oracle will have given you an ID for the VRF keypair they have\n * @dev committed to (let's call it keyHash). Create a subscription, fund it\n * @dev and your consumer contract as a consumer of it (see VRFCoordinatorInterface\n * @dev subscription management functions).\n * @dev Call requestRandomWords(keyHash, subId, minimumRequestConfirmations,\n * @dev callbackGasLimit, numWords, extraArgs),\n * @dev see (IVRFCoordinatorV2Plus for a description of the arguments).\n *\n * @dev Once the VRFCoordinatorV2Plus has received and validated the oracle's response\n * @dev to your request, it will call your contract's fulfillRandomWords method.\n *\n * @dev The randomness argument to fulfillRandomWords is a set of random words\n * @dev generated from your requestId and the blockHash of the request.\n *\n * @dev If your contract could have concurrent requests open, you can use the\n * @dev requestId returned from requestRandomWords to track which response is associated\n * @dev with which randomness request.\n * @dev See \"SECURITY CONSIDERATIONS\" for principles to keep in mind,\n * @dev if your contract could have multiple requests in flight simultaneously.\n *\n * @dev Colliding `requestId`s are cryptographically impossible as long as seeds\n * @dev differ.\n *\n * *****************************************************************************\n * @dev SECURITY CONSIDERATIONS\n *\n * @dev A method with the ability to call your fulfillRandomness method directly\n * @dev could spoof a VRF response with any random value, so it's critical that\n * @dev it cannot be directly called by anything other than this base contract\n * @dev (specifically, by the VRFConsumerBaseV2Plus.rawFulfillRandomness method).\n *\n * @dev For your users to trust that your contract's random behavior is free\n * @dev from malicious interference, it's best if you can write it so that all\n * @dev behaviors implied by a VRF response are executed *during* your\n * @dev fulfillRandomness method. If your contract must store the response (or\n * @dev anything derived from it) and use it later, you must ensure that any\n * @dev user-significant behavior which depends on that stored value cannot be\n * @dev manipulated by a subsequent VRF request.\n *\n * @dev Similarly, both miners and the VRF oracle itself have some influence\n * @dev over the order in which VRF responses appear on the blockchain, so if\n * @dev your contract could have multiple VRF requests in flight simultaneously,\n * @dev you must ensure that the order in which the VRF responses arrive cannot\n * @dev be used to manipulate your contract's user-significant behavior.\n *\n * @dev Since the block hash of the block which contains the requestRandomness\n * @dev call is mixed into the input to the VRF *last*, a sufficiently powerful\n * @dev miner could, in principle, fork the blockchain to evict the block\n * @dev containing the request, forcing the request to be included in a\n * @dev different block with a different hash, and therefore a different input\n * @dev to the VRF. However, such an attack would incur a substantial economic\n * @dev cost. This cost scales with the number of blocks the VRF oracle waits\n * @dev until it calls responds to a request. It is for this reason that\n * @dev that you can signal to an oracle you'd like them to wait longer before\n * @dev responding to the request (however this is not enforced in the contract\n * @dev and so remains effective only in the case of unmodified oracle software).\n */\nabstract contract VRFConsumerBaseV2Plus is IVRFMigratableConsumerV2Plus, ConfirmedOwner {\n  error OnlyCoordinatorCanFulfill(address have, address want);\n  error OnlyOwnerOrCoordinator(address have, address owner, address coordinator);\n  error ZeroAddress();\n\n  // s_vrfCoordinator should be used by consumers to make requests to vrfCoordinator\n  // so that coordinator reference is updated after migration\n  IVRFCoordinatorV2Plus public s_vrfCoordinator;\n\n  /**\n   * @param _vrfCoordinator address of VRFCoordinator contract\n   */\n  constructor(address _vrfCoordinator) ConfirmedOwner(msg.sender) {\n    if (_vrfCoordinator == address(0)) {\n      revert ZeroAddress();\n    }\n    s_vrfCoordinator = IVRFCoordinatorV2Plus(_vrfCoordinator);\n  }\n\n  /**\n   * @notice fulfillRandomness handles the VRF response. Your contract must\n   * @notice implement it. See \"SECURITY CONSIDERATIONS\" above for important\n   * @notice principles to keep in mind when implementing your fulfillRandomness\n   * @notice method.\n   *\n   * @dev VRFConsumerBaseV2Plus expects its subcontracts to have a method with this\n   * @dev signature, and will call it once it has verified the proof\n   * @dev associated with the randomness. (It is triggered via a call to\n   * @dev rawFulfillRandomness, below.)\n   *\n   * @param requestId The Id initially returned by requestRandomness\n   * @param randomWords the VRF output expanded to the requested number of words\n   */\n  // solhint-disable-next-line chainlink-solidity/prefix-internal-functions-with-underscore\n  function fulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) internal virtual;\n\n  // rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF\n  // proof. rawFulfillRandomness then calls fulfillRandomness, after validating\n  // the origin of the call\n  function rawFulfillRandomWords(uint256 requestId, uint256[] calldata randomWords) external {\n    if (msg.sender != address(s_vrfCoordinator)) {\n      revert OnlyCoordinatorCanFulfill(msg.sender, address(s_vrfCoordinator));\n    }\n    fulfillRandomWords(requestId, randomWords);\n  }\n\n  /**\n   * @inheritdoc IVRFMigratableConsumerV2Plus\n   */\n  function setCoordinator(address _vrfCoordinator) external override onlyOwnerOrCoordinator {\n    if (_vrfCoordinator == address(0)) {\n      revert ZeroAddress();\n    }\n    s_vrfCoordinator = IVRFCoordinatorV2Plus(_vrfCoordinator);\n\n    emit CoordinatorSet(_vrfCoordinator);\n  }\n\n  modifier onlyOwnerOrCoordinator() {\n    if (msg.sender != owner() && msg.sender != address(s_vrfCoordinator)) {\n      revert OnlyOwnerOrCoordinator(msg.sender, owner(), address(s_vrfCoordinator));\n    }\n    _;\n  }\n}\n"
    },
    "lib/chainlink-brownie-contracts/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.4;\n\n// End consumer library.\nlibrary VRFV2PlusClient {\n  // extraArgs will evolve to support new features\n  bytes4 public constant EXTRA_ARGS_V1_TAG = bytes4(keccak256(\"VRF ExtraArgsV1\"));\n  struct ExtraArgsV1 {\n    bool nativePayment;\n  }\n\n  struct RandomWordsRequest {\n    bytes32 keyHash;\n    uint256 subId;\n    uint16 requestConfirmations;\n    uint32 callbackGasLimit;\n    uint32 numWords;\n    bytes extraArgs;\n  }\n\n  function _argsToBytes(ExtraArgsV1 memory extraArgs) internal pure returns (bytes memory bts) {\n    return abi.encodeWithSelector(EXTRA_ARGS_V1_TAG, extraArgs);\n  }\n}\n"
    },
    "lib/chainlink-brownie-contracts/contracts/src/v0.8/vrf/dev/interfaces/IVRFCoordinatorV2Plus.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {VRFV2PlusClient} from \"../libraries/VRFV2PlusClient.sol\";\nimport {IVRFSubscriptionV2Plus} from \"./IVRFSubscriptionV2Plus.sol\";\n\n// Interface that enables consumers of VRFCoordinatorV2Plus to be future-proof for upgrades\n// This interface is supported by subsequent versions of VRFCoordinatorV2Plus\ninterface IVRFCoordinatorV2Plus is IVRFSubscriptionV2Plus {\n  /**\n   * @notice Request a set of random words.\n   * @param req - a struct containing following fields for randomness request:\n   * keyHash - Corresponds to a particular oracle job which uses\n   * that key for generating the VRF proof. Different keyHash's have different gas price\n   * ceilings, so you can select a specific one to bound your maximum per request cost.\n   * subId  - The ID of the VRF subscription. Must be funded\n   * with the minimum subscription balance required for the selected keyHash.\n   * requestConfirmations - How many blocks you'd like the\n   * oracle to wait before responding to the request. See SECURITY CONSIDERATIONS\n   * for why you may want to request more. The acceptable range is\n   * [minimumRequestBlockConfirmations, 200].\n   * callbackGasLimit - How much gas you'd like to receive in your\n   * fulfillRandomWords callback. Note that gasleft() inside fulfillRandomWords\n   * may be slightly less than this amount because of gas used calling the function\n   * (argument decoding etc.), so you may need to request slightly more than you expect\n   * to have inside fulfillRandomWords. The acceptable range is\n   * [0, maxGasLimit]\n   * numWords - The number of uint256 random values you'd like to receive\n   * in your fulfillRandomWords callback. Note these numbers are expanded in a\n   * secure way by the VRFCoordinator from a single random value supplied by the oracle.\n   * extraArgs - abi-encoded extra args\n   * @return requestId - A unique identifier of the request. Can be used to match\n   * a request to a response in fulfillRandomWords.\n   */\n  function requestRandomWords(VRFV2PlusClient.RandomWordsRequest calldata req) external returns (uint256 requestId);\n}\n"
    },
    "lib/chainlink-brownie-contracts/contracts/src/v0.8/vrf/dev/interfaces/IVRFMigratableConsumerV2Plus.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @notice The IVRFMigratableConsumerV2Plus interface defines the\n/// @notice method required to be implemented by all V2Plus consumers.\n/// @dev This interface is designed to be used in VRFConsumerBaseV2Plus.\ninterface IVRFMigratableConsumerV2Plus {\n  event CoordinatorSet(address vrfCoordinator);\n\n  /// @notice Sets the VRF Coordinator address\n  /// @notice This method should only be callable by the coordinator or contract owner\n  function setCoordinator(address vrfCoordinator) external;\n}\n"
    },
    "lib/chainlink-brownie-contracts/contracts/src/v0.8/shared/access/ConfirmedOwner.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {ConfirmedOwnerWithProposal} from \"./ConfirmedOwnerWithProposal.sol\";\n\n/// @title The ConfirmedOwner contract\n/// @notice A contract with helpers for basic contract ownership.\ncontract ConfirmedOwner is ConfirmedOwnerWithProposal {\n  constructor(address newOwner) ConfirmedOwnerWithProposal(newOwner, address(0)) {}\n}\n"
    },
    "lib/chainlink-brownie-contracts/contracts/src/v0.8/vrf/dev/interfaces/IVRFSubscriptionV2Plus.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\n/// @notice The IVRFSubscriptionV2Plus interface defines the subscription\n/// @notice related methods implemented by the V2Plus coordinator.\ninterface IVRFSubscriptionV2Plus {\n  /**\n   * @notice Add a consumer to a VRF subscription.\n   * @param subId - ID of the subscription\n   * @param consumer - New consumer which can use the subscription\n   */\n  function addConsumer(uint256 subId, address consumer) external;\n\n  /**\n   * @notice Remove a consumer from a VRF subscription.\n   * @param subId - ID of the subscription\n   * @param consumer - Consumer to remove from the subscription\n   */\n  function removeConsumer(uint256 subId, address consumer) external;\n\n  /**\n   * @notice Cancel a subscription\n   * @param subId - ID of the subscription\n   * @param to - Where to send the remaining LINK to\n   */\n  function cancelSubscription(uint256 subId, address to) external;\n\n  /**\n   * @notice Accept subscription owner transfer.\n   * @param subId - ID of the subscription\n   * @dev will revert if original owner of subId has\n   * not requested that msg.sender become the new owner.\n   */\n  function acceptSubscriptionOwnerTransfer(uint256 subId) external;\n\n  /**\n   * @notice Request subscription owner transfer.\n   * @param subId - ID of the subscription\n   * @param newOwner - proposed new owner of the subscription\n   */\n  function requestSubscriptionOwnerTransfer(uint256 subId, address newOwner) external;\n\n  /**\n   * @notice Create a VRF subscription.\n   * @return subId - A unique subscription id.\n   * @dev You can manage the consumer set dynamically with addConsumer/removeConsumer.\n   * @dev Note to fund the subscription with LINK, use transferAndCall. For example\n   * @dev  LINKTOKEN.transferAndCall(\n   * @dev    address(COORDINATOR),\n   * @dev    amount,\n   * @dev    abi.encode(subId));\n   * @dev Note to fund the subscription with Native, use fundSubscriptionWithNative. Be sure\n   * @dev  to send Native with the call, for example:\n   * @dev COORDINATOR.fundSubscriptionWithNative{value: amount}(subId);\n   */\n  function createSubscription() external returns (uint256 subId);\n\n  /**\n   * @notice Get a VRF subscription.\n   * @param subId - ID of the subscription\n   * @return balance - LINK balance of the subscription in juels.\n   * @return nativeBalance - native balance of the subscription in wei.\n   * @return reqCount - Requests count of subscription.\n   * @return owner - owner of the subscription.\n   * @return consumers - list of consumer address which are able to use this subscription.\n   */\n  function getSubscription(\n    uint256 subId\n  )\n    external\n    view\n    returns (uint96 balance, uint96 nativeBalance, uint64 reqCount, address owner, address[] memory consumers);\n\n  /*\n   * @notice Check to see if there exists a request commitment consumers\n   * for all consumers and keyhashes for a given sub.\n   * @param subId - ID of the subscription\n   * @return true if there exists at least one unfulfilled request for the subscription, false\n   * otherwise.\n   */\n  function pendingRequestExists(uint256 subId) external view returns (bool);\n\n  /**\n   * @notice Paginate through all active VRF subscriptions.\n   * @param startIndex index of the subscription to start from\n   * @param maxCount maximum number of subscriptions to return, 0 to return all\n   * @dev the order of IDs in the list is **not guaranteed**, therefore, if making successive calls, one\n   * @dev should consider keeping the blockheight constant to ensure a holistic picture of the contract state\n   */\n  function getActiveSubscriptionIds(uint256 startIndex, uint256 maxCount) external view returns (uint256[] memory);\n\n  /**\n   * @notice Fund a subscription with native.\n   * @param subId - ID of the subscription\n   * @notice This method expects msg.value to be greater than or equal to 0.\n   */\n  function fundSubscriptionWithNative(uint256 subId) external payable;\n}\n"
    },
    "lib/chainlink-brownie-contracts/contracts/src/v0.8/shared/access/ConfirmedOwnerWithProposal.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\nimport {IOwnable} from \"../interfaces/IOwnable.sol\";\n\n/// @title The ConfirmedOwner contract\n/// @notice A contract with helpers for basic contract ownership.\ncontract ConfirmedOwnerWithProposal is IOwnable {\n  address private s_owner;\n  address private s_pendingOwner;\n\n  event OwnershipTransferRequested(address indexed from, address indexed to);\n  event OwnershipTransferred(address indexed from, address indexed to);\n\n  constructor(address newOwner, address pendingOwner) {\n    // solhint-disable-next-line gas-custom-errors\n    require(newOwner != address(0), \"Cannot set owner to zero\");\n\n    s_owner = newOwner;\n    if (pendingOwner != address(0)) {\n      _transferOwnership(pendingOwner);\n    }\n  }\n\n  /// @notice Allows an owner to begin transferring ownership to a new address.\n  function transferOwnership(address to) public override onlyOwner {\n    _transferOwnership(to);\n  }\n\n  /// @notice Allows an ownership transfer to be completed by the recipient.\n  function acceptOwnership() external override {\n    // solhint-disable-next-line gas-custom-errors\n    require(msg.sender == s_pendingOwner, \"Must be proposed owner\");\n\n    address oldOwner = s_owner;\n    s_owner = msg.sender;\n    s_pendingOwner = address(0);\n\n    emit OwnershipTransferred(oldOwner, msg.sender);\n  }\n\n  /// @notice Get the current owner\n  function owner() public view override returns (address) {\n    return s_owner;\n  }\n\n  /// @notice validate, transfer ownership, and emit relevant events\n  function _transferOwnership(address to) private {\n    // solhint-disable-next-line gas-custom-errors\n    require(to != msg.sender, \"Cannot transfer to self\");\n\n    s_pendingOwner = to;\n\n    emit OwnershipTransferRequested(s_owner, to);\n  }\n\n  /// @notice validate access\n  function _validateOwnership() internal view {\n    // solhint-disable-next-line gas-custom-errors\n    require(msg.sender == s_owner, \"Only callable by owner\");\n  }\n\n  /// @notice Reverts if called by anyone other than the contract owner.\n  modifier onlyOwner() {\n    _validateOwnership();\n    _;\n  }\n}\n"
    },
    "lib/chainlink-brownie-contracts/contracts/src/v0.8/shared/interfaces/IOwnable.sol": {
      "content": "// SPDX-License-Identifier: MIT\npragma solidity ^0.8.0;\n\ninterface IOwnable {\n  function owner() external returns (address);\n\n  function transferOwnership(address recipient) external;\n\n  function acceptOwnership() external;\n}\n"
    }
  },
  "settings": {
    "remappings": [
      "@chainlink/contracts/=lib/chainlink-brownie-contracts/contracts/",
      "@solmate/=lib/solmate/src/",
      "chainlink-brownie-contracts/=lib/chainlink-brownie-contracts/contracts/src/v0.6/vendor/@arbitrum/nitro-contracts/src/",
      "ds-test/=lib/solmate/lib/ds-test/src/",
      "forge-std/=lib/forge-std/src/",
      "foundry-devops/=lib/foundry-devops/",
      "solmate/=lib/solmate/src/",
      "weird-erc20/=lib/solmate/lib/weird-erc20/src/"
    ],
    "optimizer": { "enabled": false, "runs": 200 },
    "metadata": {
      "useLiteralContent": false,
      "bytecodeHash": "ipfs",
      "appendCBOR": true
    },
    "outputSelection": {
      "*": {
        "*": [
          "abi",
          "evm.bytecode.object",
          "evm.bytecode.sourceMap",
          "evm.bytecode.linkReferences",
          "evm.deployedBytecode.object",
          "evm.deployedBytecode.sourceMap",
          "evm.deployedBytecode.linkReferences",
          "evm.deployedBytecode.immutableReferences",
          "evm.methodIdentifiers",
          "metadata"
        ]
      }
    },
    "evmVersion": "paris",
    "viaIR": false,
    "libraries": {}
  }
}