-
Notifications
You must be signed in to change notification settings - Fork 0
/
json.json
64 lines (64 loc) · 28.5 KB
/
json.json
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
{
"language": "Solidity",
"sources": {
"src/Raffle.sol": {
"content": "// Layout of Contract:\n// version\n// imports\n// errors\n// interfaces, libraries, contracts\n// Type declarations\n// State variables\n// Events\n// Modifiers\n// Functions\n\n// Layout of Functions:\n// constructor\n// receive function (if exists)\n// fallback function (if exists)\n// external\n// public\n// internal\n// private\n// view & pure functions\n\n// SPDX-License-Identifier: MIT\npragma solidity ^0.8.19;\n\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/**\n * @title Raffle - Simple raffle contract\n * @author Antony Mapfumo\n * @notice This is a simple contract for a raffle\n * @dev This contract is not audited. This contract implements Chainlink VRFv2.5\n */\ncontract Raffle is VRFConsumerBaseV2Plus {\n // Custom errors\n error Raffle__SendMoreToEnterRaffle();\n error Raffle__NotEnoughTimePassed();\n error Raffle__TransferFailed();\n error Raffle__RaffleNotOpen();\n error Raffle__UpkeepNotNeeded(uint256 balance, uint256 playersLength, uint256 raffleState);\n\n /* Type Declarations */\n // keep track of the Raffle state\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 // \"i\" for mmutable. immutables are gas efficient\n uint256 private immutable i_entranceFee;\n // @dev the duration of the lottery in secondss\n uint256 private immutable i_interval; // interval between pickWinner() calls\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 uint256 private s_lastTimeStamp;\n address private s_recentWinner;\n RaffleState private s_raffleState;\n\n /**\n * Events\n */\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, // keyHas\n uint256 subscriptionId,\n uint32 callbackGasLimit\n ) VRFConsumerBaseV2Plus(vrfCoordinator) {\n // Since we inheriiting from VRFConsumerBaseV2Plus, we also need to pass parameters to its constructor\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 // as of Solidity 0.8.4 you can use use custom errors like \"error NotEnoughETH()\"\n // require(msg.value == i_entranceFee, \"Not enough ETH sent!\");\n // storing the above error message as a strng costs a lot of gas\n // so we can use a custom error instead\n // custom errors are gas efficient\n if (msg.value < i_entranceFee) {\n revert Raffle__SendMoreToEnterRaffle();\n }\n\n if (s_raffleState != RaffleState.OPEN) {\n revert Raffle__RaffleNotOpen();\n }\n // push the player to the players array\n s_players.push(payable(msg.sender));\n // there's a rule of thumb whenver we up date a storage variable, emit an event\n // 1. Make miigration easier\n // 2. Makes frond end \"indexing\" easier\n emit RaffleEntered(msg.sender); // emit an event\n }\n\n /* when should the winner be picked \n * @dev This is the function that the Chainlink wiill 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 raffle is open\n * 3. The contract has ETH\n * 4. Implicitly, your subscription has LINK\n * @param - ignored\n * @return upkeepNeeded - true if its time to restart the lottery\n * @return - ignored\n */\n function checkUpKeep(bytes memory /* checkData */ )\n public\n 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\n upkeepNeeded = timeHasPassed && isOpen && hasBalance && hasPlayers;\n //performData = abi.encode(s_lastTimeStamp);\n return (upkeepNeeded, \"\");\n }\n\n // 1. Get a random number\n // 2. use the random number to pick a winner\n // 3. Be automatically called\n function performUpKeep(bytes calldata /* performData */ ) external {\n // check if enough time has passed\n (bool upkeepNdeeded,) = checkUpKeep(\"\");\n if (!upkeepNdeeded) {\n revert Raffle__UpkeepNotNeeded(address(this).balance, s_players.length, uint256(s_raffleState));\n }\n s_raffleState = RaffleState.CALCULATING;\n\n // Get a random number VRF 2.5\n // Two step process\n // 1. Request RNG (Random Number Generator)\n VRFV2PlusClient.RandomWordsRequest memory request = VRFV2PlusClient.RandomWordsRequest({\n keyHash: i_keyHash, // some gas price to work with the chainlink node\n subId: i_subscriptionId, // how we are going to fund the oracle to work wth chanlink VRF\n requestConfirmations: REQUEST_CONFIRMATIONS, // how many blocks should we wait before before we can get the random number\n callbackGasLimit: i_callbackGasLimit, // so we don't overspend gas\n numWords: NUM_WORDS, // number of random numbers that we want\n extraArgs: VRFV2PlusClient._argsToBytes(\n // Set nativePayment to true to pay for VRF requests with Sepolia ETH instead off LINK\n VRFV2PlusClient.ExtraArgsV1({nativePayment: false})\n )\n });\n uint256 requestId = s_vrfCoordinator.requestRandomWords(request);\n // redudant (since VRFCoordinator is also emitting this event) but good for debugging\n emit RequestedRaffleWinner(requestId);\n }\n\n // This need to be implemented as defined in the abstract contract\n // when chainlink node giives us a random number, we need to do some stuff using the function fuullfillRandomWords\n // use the keyword override because it's marked as virtual in the abstract contract\n // CEI - Check Effects Interactions\n function fulfillRandomWords(uint256, /*requestId*/ uint256[] calldata randomWords) internal virtual override {\n // Checks - Its more gas efficient to start with checks\n\n // Effect (Internal Contract State Changes)\n uint256 indexOfWinner = randomWords[0] % s_players.length;\n address payable recentWinner = s_players[indexOfWinner];\n s_recentWinner = recentWinner;\n s_raffleState = RaffleState.OPEN; // reset the lottery state to open\n s_players = new address payable[](0); // reset the players array\n emit WinnerPicked(s_recentWinner);\n\n // Interactions (External Contract Interactions)\n (bool success,) = recentWinner.call{value: address(this).balance}(\"\");\n // give the winner the entrire balance of \"this\" contract\n if (!success) {\n revert Raffle__TransferFailed();\n }\n }\n\n /**\n * Getters\n */\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/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": true, "runs": 200 },
"metadata": {
"useLiteralContent": false,
"bytecodeHash": "ipfs",
"appendCBOR": true
},
"outputSelection": {
"*": {
"*": [
"abi",
"evm.bytecode",
"evm.deployedBytecode",
"evm.methodIdentifiers",
"metadata"
]
}
},
"evmVersion": "paris",
"viaIR": false,
"libraries": {}
}
}