json.json

{"language":"Solidity","sources":{"src/Raffle.sol":{"content":"//SPDX-License-Identifier: MIT\npragma solidity ^0.8.24;\n\n/***** Imports *****/\nimport {VRFConsumerBaseV2Plus} from \"@chainlink/contracts/src/v0.8/vrf/dev/VRFConsumerBaseV2Plus.sol\";\nimport {VRFV2PlusClient} from \"@chainlink/contracts/src/v0.8/vrf/dev/libraries/VRFV2PlusClient.sol\";\n\n/// @title A sample raffle contract\n/// @author Nabil Ziani\n/// @notice This contract is for creating a sample raffle\n/// @dev Implements Chainlink VRF\ncontract Raffle is VRFConsumerBaseV2Plus {\n    /***** Errors *****/\n    error Raffle__NotEnoughEth();\n    error Raffle__TranferFailed();\n    error Raffle__RaffleNotOpen();\n    error Raffle__NotEnoughTimePassed();\n    error Raffle__UpkeepNotNeeded(\n        uint256 balance,\n        uint256 playersLength,\n        uint256 raffleState\n    );\n\n    /***** Type Declarations *****/\n    enum RaffleState {\n        OPEN,\n        CALCULATING\n    }\n\n    /***** State Variables *****/\n    uint16 private constant REQUEST_CONFIRMATIONS = 3;\n    uint32 private constant NUM_WORDS = 1;\n\n    uint256 private immutable i_entranceFee;\n    // @dev The duration of the lottery in seconds\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\n    uint256 private s_lastTimeStamp;\n    address payable[] private s_players;\n    address private s_recentWinner;\n    RaffleState private s_raffleState;\n\n    /***** Events *****/\n    event RaffleEntered(address indexed player);\n    event WinnerPicked(address indexed winner);\n    event RequestedRaffleWinner(uint256 indexed requestId);\n\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;\n        s_raffleState = RaffleState.OPEN;\n    }\n\n    function enterRaffle() external payable {\n        if (msg.value < i_entranceFee) {\n            revert Raffle__NotEnoughEth();\n        }\n\n        if (s_raffleState != RaffleState.OPEN) {\n            revert Raffle__RaffleNotOpen();\n        }\n\n        s_players.push(payable(msg.sender));\n\n        // Emitting events make migrations and front-end indexing easier\n        emit RaffleEntered(msg.sender);\n    }\n\n    /// @notice When should the winner be picked?\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. Inmplicitly, your subscription has $LINK\n    /// @param - ignored\n    /// @return upkeepNeeded - true if it's time to restart the lottery\n    /// @return - ignored\n    function checkUpkeep(\n        bytes memory /* checkData */\n    ) public view returns (bool upkeepNeeded, bytes memory /* performData */) {\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\n        upkeepNeeded = timeHasPassed && isOpen && hasBalance && hasPlayers;\n        return (upkeepNeeded, \"\");\n    }\n\n    function performUpkeep(bytes calldata /* performData */) external {\n        (bool upkeepNeeded, ) = checkUpkeep(\"\");\n\n        if (!upkeepNeeded) {\n            revert Raffle__UpkeepNotNeeded(\n                address(this).balance,\n                s_players.length,\n                uint256(s_raffleState)\n            );\n        }\n\n        s_raffleState = RaffleState.CALCULATING;\n\n        VRFV2PlusClient.RandomWordsRequest memory request = VRFV2PlusClient\n            .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                    VRFV2PlusClient.ExtraArgsV1({nativePayment: false})\n                )\n            });\n\n        // Get our random nmber: https://docs.chain.link/vrf/v2-5/subscription/get-a-random-number\n        uint256 requestId = s_vrfCoordinator.requestRandomWords(request);\n        emit RequestedRaffleWinner(requestId);\n    }\n\n    // CEI: Checks, Effects, Interactions Pattern\n    function fulfillRandomWords(\n        uint256 /* requestId */,\n        uint256[] calldata randomWords\n    ) internal override {\n        uint256 indexOfWinner = randomWords[0] % s_players.length;\n\n        s_recentWinner = s_players[indexOfWinner];\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        (bool success, ) = s_recentWinner.call{value: address(this).balance}(\n            \"\"\n        );\n\n        if (!success) {\n            revert Raffle__TranferFailed();\n        }\n    }\n\n    /***** Getter Functions *****/\n    function getEntranceFee() external view returns (uint256) {\n        return i_entranceFee;\n    }\n\n    function getRaffleState() external view returns (RaffleState) {\n        return s_raffleState;\n    }\n\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    function getRecentWinner() external view returns (address) {\n        return s_recentWinner;\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/","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":true,"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":"cancun","viaIR":false,"libraries":{}}}