From 0972640b32025ed8c5de9b41e85bdcc1c9cf5e7c Mon Sep 17 00:00:00 2001 From: mryamz Date: Wed, 24 Apr 2024 02:03:21 -0700 Subject: [PATCH] update --- contracts/Operator/NodeAccount.sol | 8 +++++- contracts/Operator/OperatorDistributor.sol | 33 +++++++++++++++++----- gas-report.txt | 24 ++++++++-------- output.log | 4 +-- 4 files changed, 47 insertions(+), 22 deletions(-) diff --git a/contracts/Operator/NodeAccount.sol b/contracts/Operator/NodeAccount.sol index 03e36fcb..3177c610 100644 --- a/contracts/Operator/NodeAccount.sol +++ b/contracts/Operator/NodeAccount.sol @@ -178,7 +178,7 @@ contract NodeAccount is UpgradeableBase, Errors { } IMinipool minipool = IMinipool(_minipool); - OperatorDistributor(_directory.getOperatorDistributorAddress()).onNodeOperatorDissolved( + OperatorDistributor(_directory.getOperatorDistributorAddress()).onNodeMinipoolDestroy( nodeOperator, configs[_minipool].bondAmount ); @@ -224,6 +224,12 @@ contract NodeAccount is UpgradeableBase, Errors { ) external onlyNodeOperatorOrProtocol hasConfig(_minipool) { IMinipool minipool = IMinipool(_minipool); minipool.distributeBalance(_rewardsOnly); + if (minipool.getFinalised()) { + OperatorDistributor(_directory.getOperatorDistributorAddress()).onNodeMinipoolDestroy( + nodeOperator, + configs[_minipool].bondAmount + ); + } } function setDelegate(address _newDelegate) external onlyNodeOperatorOrProtocol { diff --git a/contracts/Operator/OperatorDistributor.sol b/contracts/Operator/OperatorDistributor.sol index e432c8ec..6c430d1a 100644 --- a/contracts/Operator/OperatorDistributor.sol +++ b/contracts/Operator/OperatorDistributor.sol @@ -24,7 +24,11 @@ contract OperatorDistributor is UpgradeableBase, Errors { event MinipoolCreated(address indexed _minipoolAddress, address indexed _nodeAddress); event MinipoolDestroyed(address indexed _minipoolAddress, address indexed _nodeAddress); event WarningNoMiniPoolsToHarvest(); - event WarningMinipoolNotStaking(address indexed _minipoolAddress, MinipoolStatus indexed _status); + event WarningMinipoolNotStaking( + address indexed _minipoolAddress, + MinipoolStatus indexed _status, + bool indexed _isFinalized + ); using Math for uint256; @@ -361,9 +365,11 @@ contract OperatorDistributor is UpgradeableBase, Errors { IMinipool minipool = IMinipool(minipoolAddresses[index]); MinipoolStatus minipoolStatus = minipool.getStatus(); + bool isFinalized = minipool.getFinalised(); console.log('_processNextMinipool.status=', uint256(minipoolStatus)); - if (minipoolStatus != MinipoolStatus.Staking) { - emit WarningMinipoolNotStaking(address(minipool), minipoolStatus); + console.log('_processNextMinipool.isFinalized=', isFinalized); + if (minipoolStatus != MinipoolStatus.Staking || isFinalized) { + emit WarningMinipoolNotStaking(address(minipool), minipoolStatus, isFinalized); return; } @@ -379,9 +385,22 @@ contract OperatorDistributor is UpgradeableBase, Errors { rebalanceRplStake(nodeAddress, ethStaked); uint256 totalBalance = address(minipool).balance - minipool.getNodeRefundBalance(); - NodeAccount( - NodeAccountFactory(_directory.getNodeAccountFactoryAddress()).minipoolNodeAccountMap(address(minipool)) - ).distributeBalance(totalBalance < 8 ether, address(minipool)); + + if (totalBalance < 8 ether) { + NodeAccount( + NodeAccountFactory(_directory.getNodeAccountFactoryAddress()).minipoolNodeAccountMap(address(minipool)) + ).distributeBalance(true, address(minipool)); + } else { + if(!minipool.userDistributeAllowed()) { + // alternatives for try-catch + // 1) integrate settings contract and fetch from storage bloating setup process for only use here + // 2) use mapping to track which users have begunUserDistribute + try minipool.beginUserDistribute() {} catch {} + } else { + // we do it this way to prevent minipool auto finalizations + minipool.distributeBalance(false); + } + } nextMinipoolHavestIndex++; } @@ -405,7 +424,7 @@ contract OperatorDistributor is UpgradeableBase, Errors { targetStakeRatio = _targetStakeRatio; } - function onNodeOperatorDissolved(address _nodeOperator, uint256 _bond) external onlyProtocol { + function onNodeMinipoolDestroy(address _nodeOperator, uint256 _bond) external onlyProtocol { fundedEth -= _bond; nodeOperatorEthStaked[_nodeOperator] -= _bond; } diff --git a/gas-report.txt b/gas-report.txt index f62d3f06..f0c70c57 100644 --- a/gas-report.txt +++ b/gas-report.txt @@ -25,11 +25,11 @@ ·····························|·························|·············|·············|·············|···············|·············· | MockSanctions · addBlacklist · - · - · 43876 · 3 · - │ ·····························|·························|·············|·············|·············|···············|·············· -| NodeAccount · stake · 230278 · 247378 · 240538 · 10 · - │ +| NodeAccount · stake · 230278 · 247378 · 237118 · 10 · - │ ·····························|·························|·············|·············|·············|···············|·············· -| NodeAccountFactory · createNewNodeAccount · 3162041 · 3429071 · 3308661 · 13 · - │ +| NodeAccountFactory · createNewNodeAccount · 3161997 · 3429027 · 3300069 · 13 · - │ ·····························|·························|·············|·············|·············|···············|·············· -| OperatorDistributor · processNextMinipool · 187615 · 768574 · 458064 · 5 · - │ +| OperatorDistributor · processNextMinipool · 171404 · 382241 · 294529 · 5 · - │ ·····························|·························|·············|·············|·············|···············|·············· | PriceFetcher · useFallback · - · - · 41967 · 2 · - │ ·····························|·························|·············|·············|·············|···············|·············· @@ -37,9 +37,9 @@ ·····························|·························|·············|·············|·············|···············|·············· | RocketDAOProtocol · bootstrapSettingUint · - · - · 86433 · 2 · - │ ·····························|·························|·············|·············|·············|···············|·············· -| RocketDepositPool · assignDeposits · 116147 · 116152 · 116148 · 10 · - │ +| RocketDepositPool · assignDeposits · - · - · 116147 · 10 · - │ ·····························|·························|·············|·············|·············|···············|·············· -| RocketDepositPool · deposit · 193401 · 376260 · 319168 · 10 · - │ +| RocketDepositPool · deposit · 324960 · 376260 · 345480 · 10 · - │ ·····························|·························|·············|·············|·············|···············|·············· | RocketStorage · setAddress · 51027 · 51051 · 51048 · 50 · - │ ·····························|·························|·············|·············|·············|···············|·············· @@ -71,7 +71,7 @@ ·····························|·························|·············|·············|·············|···············|·············· | WETHVault · setRplCoverageRatio · - · - · 44251 · 1 · - │ ·····························|·························|·············|·············|·············|···············|·············· -| WhitelistV2 · addOperator · 367807 · 1053892 · 494870 · 27 · - │ +| WhitelistV2 · addOperator · 367807 · 641964 · 464357 · 27 · - │ ·····························|·························|·············|·············|·············|···············|·············· | WhitelistV2 · addOperators · - · - · 675408 · 4 · - │ ·····························|·························|·············|·············|·············|···············|·············· @@ -81,9 +81,9 @@ ·····························|·························|·············|·············|·············|···············|·············· | WhitelistV2 · setOperatorController · 56325 · 58329 · 57884 · 9 · - │ ·····························|·························|·············|·············|·············|···············|·············· -| YieldDistributor · finalizeInterval · 271319 · 294273 · 278970 · 3 · - │ +| YieldDistributor · finalizeInterval · 271319 · 299489 · 280709 · 3 · - │ ·····························|·························|·············|·············|·············|···············|·············· -| YieldDistributor · harvest · 279354 · 814048 · 695603 · 14 · - │ +| YieldDistributor · harvest · 284570 · 390315 · 344294 · 14 · - │ ·····························|·························|·············|·············|·············|···············|·············· | Deployments · · % of limit · │ ·······················································|·············|·············|·············|···············|·············· @@ -95,7 +95,7 @@ ·······················································|·············|·············|·············|···············|·············· | Directory · - · - · 3082153 · 10.3 % · - │ ·······················································|·············|·············|·············|···············|·············· -| FundRouter · - · - · 2386599 · 8 % · - │ +| FundRouter · - · - · 2386611 · 8 % · - │ ·······················································|·············|·············|·············|···············|·············· | MockERC20 · - · - · 868977 · 2.9 % · - │ ·······················································|·············|·············|·············|···············|·············· @@ -107,11 +107,11 @@ ·······················································|·············|·············|·············|···············|·············· | MockUniswapV3Pool · - · - · 131311 · 0.4 % · - │ ·······················································|·············|·············|·············|···············|·············· -| NodeAccount · - · - · 4115021 · 13.7 % · - │ +| NodeAccount · - · - · 4189498 · 14 % · - │ ·······················································|·············|·············|·············|···············|·············· | NodeAccountFactory · - · - · 2299132 · 7.7 % · - │ ·······················································|·············|·············|·············|···············|·············· -| OperatorDistributor · - · - · 4026190 · 13.4 % · - │ +| OperatorDistributor · - · - · 4151259 · 13.8 % · - │ ·······················································|·············|·············|·············|···············|·············· | PriceFetcher · - · - · 1300505 · 4.3 % · - │ ·······················································|·············|·············|·············|···············|·············· @@ -273,7 +273,7 @@ ·······················································|·············|·············|·············|···············|·············· | Whitelist · - · - · 2323088 · 7.7 % · - │ ·······················································|·············|·············|·············|···············|·············· -| WhitelistV2 · - · - · 2329709 · 7.8 % · - │ +| WhitelistV2 · - · - · 2329697 · 7.8 % · - │ ·······················································|·············|·············|·············|···············|·············· | YieldDistributor · - · - · 3087220 · 10.3 % · - │ ·------------------------------------------------------|-------------|-------------|-------------|---------------|-------------· \ No newline at end of file diff --git a/output.log b/output.log index 3e8386c7..c43607a2 100644 --- a/output.log +++ b/output.log @@ -355,7 +355,7 @@ price 51127333500000000000 1) Validator Account Factory Run the MOAT (Mother Of all Atomic Transactions): - Error: cannot estimate gas; transaction may fail or may require manual gas limit [ See: https://links.ethers.org/v5-errors-UNPREDICTABLE_GAS_LIMIT ] (reason="Transaction reverted: contract call run out of gas and made the transaction revert", method="estimateGas", transaction={"from":"0x1CBd3b2770909D4e10f157cABC84C7264073C9Ec","to":"0x10e38eE9dd4C549b61400Fc19347D00eD3edAfC4","value":{"type":"BigNumber","hex":"0x6f05b59d3b200000"},"accessList":null}, error={"stackTrace":[{"type":2,"address":{"type":"Buffer","data":[16,227,142,233,221,76,84,155,97,64,15,193,147,71,208,14,211,237,175,196]}},{"type":0,"sourceReference":{"function":"","contract":"OperatorDistributor","sourceName":"contracts/Operator/OperatorDistributor.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';\n\nimport '../UpgradeableBase.sol';\nimport '../Whitelist/Whitelist.sol';\nimport '../FundRouter.sol';\nimport '../PriceFetcher.sol';\nimport '../Tokens/WETHVault.sol';\n\nimport '../Utils/Constants.sol';\nimport '../Utils/Errors.sol';\n\nimport '../Interfaces/IWETH.sol';\nimport '../Interfaces/RocketPool/IRocketStorage.sol';\nimport '../Interfaces/RocketPool/IMinipool.sol';\nimport '../Interfaces/RocketPool/IRocketNodeManager.sol';\nimport '../Interfaces/RocketPool/IRocketNodeStaking.sol';\n\ncontract OperatorDistributor is UpgradeableBase, Errors {\n event MinipoolCreated(address indexed _minipoolAddress, address indexed _nodeAddress);\n event MinipoolDestroyed(address indexed _minipoolAddress, address indexed _nodeAddress);\n event WarningNoMiniPoolsToHarvest();\n event WarningMinipoolNotStaking(address indexed _minipoolAddress, MinipoolStatus indexed _status);\n\n using Math for uint256;\n\n // The total amount of Ether (ETH) funded or allocated by the contract.\n // This variable keeps track of the ETH resources managed within this contract,\n uint256 public fundedEth;\n\n // The total amount of Rocket Pool tokens (RPL) funded or allocated by the contract.\n // This field is used to track the RPL token balance managed by the contract,\n uint256 public fundedRpl;\n\n address[] public minipoolAddresses;\n\n uint256 public nextMinipoolHavestIndex;\n uint256 public targetStakeRatio;\n\n uint256 public numMinipoolsProcessedPerInterval;\n\n uint256 public requiredLEBStaked;\n\n mapping(address => uint256) public minipoolIndexMap;\n mapping(address => uint256) public minipoolAmountFundedEth;\n mapping(address => uint256) public minipoolAmountFundedRpl;\n\n mapping(address => address[]) public nodeOperatorOwnedMinipools;\n mapping(address => uint256) public nodeOperatorEthStaked;\n\n constructor() initializer {}\n\n /**\n * @notice Initializes the contract with the provided storage address.\n * @dev This function should only be called once, during contract creation or proxy initialization.\n * It overrides the `initialize` function from a parent contract.\n * @param _directory The address of the storage contract.\n */\n function initialize(address _directory) public override initializer {\n super.initialize(_directory);\n targetStakeRatio = 1.5e18; // 150%\n numMinipoolsProcessedPerInterval = 1;\n\n // defaulting these to 8eth to only allow LEB8 minipools\n requiredLEBStaked = 8 ether;\n }\n\n /**\n * @notice Receives incoming Ether and adds it to the queued balance.\n * @dev This is the fallback function that is called when Ether is sent directly to the contract.\n */\n receive() external payable {\n address payable dp = _directory.getDepositPoolAddress();\n console.log('fallback od initial');\n console.log(address(this).balance);\n\n if (msg.sender != dp) {\n (bool success, ) = dp.call{value: msg.value}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n }\n\n console.log('fallback od final');\n console.log(address(this).balance);\n }\n\n function _rebalanceLiquidity() internal nonReentrant {\n address payable dp = _directory.getDepositPoolAddress();\n (bool success, ) = dp.call{value: address(this).balance}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n\n IERC20 rpl = IERC20(_directory.getRPLAddress());\n SafeERC20.safeTransfer(rpl, dp, rpl.balanceOf(address(this)));\n FundRouter(dp).sendRplToDistributors();\n }\n\n /// @notice Gets the total ETH value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function sums up the balance of this contract with the amount of funded ETH across all minipools.\n /// Ensure that all sources of ETH (like the OperatorDistributor) are properly accounted for in the calculation.\n /// @return The total amount of Ether locked inside the protocol.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + fundedEth;\n }\n\n /// @notice Gets the total RPL value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function calculates the total RPL by summing up the balance of RPL tokens of this contract\n /// with the amount of funded RPL across all minipools. It retrieves the RPL token address from the `_directory` contract.\n /// Ensure that all sources of RPL (like the OperatorDistributor) are accurately accounted for.\n /// @return The total amount of RPL tokens locked inside the protocol.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this)) + fundedRpl;\n }\n\n /**\n * @notice Removes a minipool address from the tracked list when a node operator exits.\n * @dev This function efficiently reorders the minipool addresses array and updates the index map.\n * It then resets the funded amount of ETH and RPL tokens for the removed minipool.\n * Should only be called by authorized protocol actors or admin.\n * @param _address The address of the minipool to be removed.\n *\n * Emits a `MinipoolDestroyed` event upon successful removal.\n */ function removeMinipoolAddress(address _address) public onlyProtocolOrAdmin {\n uint index = minipoolIndexMap[_address] - 1;\n require(index < minipoolAddresses.length, 'Address not found.');\n\n // Move the last address into the spot located by index\n address lastAddress = minipoolAddresses[minipoolAddresses.length - 1];\n minipoolAddresses[index] = lastAddress;\n minipoolIndexMap[lastAddress] = index;\n\n // Remove the last address\n minipoolAddresses.pop();\n delete minipoolIndexMap[_address];\n\n // Set amount funded to 0 since it's being returned to DP\n minipoolAmountFundedEth[_address] = 0;\n minipoolAmountFundedRpl[_address] = 0;\n\n emit MinipoolDestroyed(_address, IMinipool(_address).getNodeAddress());\n }\n\n /**\n * @notice Removes a node operator and all associated minipools.\n * @dev Iterates through all minipools owned by the node operator and removes them.\n * This action cannot be reversed, so it should be executed with caution.\n * Only authorized protocol actors or admin can call this function.\n * @param _address The address of the node operator to be removed.\n */\n function removeNodeOperator(address _address) external onlyProtocolOrAdmin {\n // remove all minipools owned by node operator\n address[] memory minipools = nodeOperatorOwnedMinipools[_address];\n for (uint i = 0; i < minipools.length; i++) {\n removeMinipoolAddress(minipools[i]);\n }\n delete nodeOperatorOwnedMinipools[_address];\n }\n\n /**\n * @notice Stakes the minimum required RPL tokens on behalf of a node.\n * @dev This function first fetches the node's minimum RPL stake requirement,\n * approves the Node Staking contract to spend the RPL, and then stakes the RPL for the node.\n * It assumes that the contract already holds enough RPL tokens for the staking process.\n * @param _nodeAddress The address of the node for which RPL should be staked.\n */\n function _stakeRPLFor(address _nodeAddress) internal {\n IRocketNodeStaking nodeStaking = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress());\n uint256 minimumRplStake = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress())\n .getNodeMinimumRPLStake(_nodeAddress);\n\n fundedRpl += minimumRplStake;\n\n // approve the node staking contract to spend the RPL\n RocketTokenRPLInterface rpl = RocketTokenRPLInterface(_directory.getRPLAddress());\n require(rpl.approve(getDirectory().getRocketNodeStakingAddress(), minimumRplStake));\n\n // update amount funded rpl\n minipoolAmountFundedRpl[_nodeAddress] = minimumRplStake;\n\n nodeStaking.stakeRPLFor(_nodeAddress, minimumRplStake);\n }\n\n /**\n * @notice Prepares a node for minipool creation by setting up necessary staking and validations.\n * @dev This function first validates the node's withdrawal address, then calculates the required amount of\n * RPL to stake based on the number of validators associated with the node, and performs a top-up.\n * Only the protocol or admin can call this function.\n * @param _NodeAccount The address of the validator account belonging to the Node Operator\n */\n function provisionLiquiditiesForMinipoolCreation(\n address _nodeOperator,\n address _NodeAccount,\n uint256 _bond\n ) external onlyProtocolOrAdmin {\n _rebalanceLiquidity();\n require(_bond == requiredLEBStaked, 'OperatorDistributor: Bad _bond amount, should be `requiredLEBStaked`');\n fundedEth += _bond;\n nodeOperatorEthStaked[_nodeOperator] += _bond;\n\n // by default this bonds 150% of stake according to max stake defined here: https://docs.rocketpool.net/guides/node/create-validator#staking-rpl\n // performTopUp(_NodeAccount, nodeOperatorEthStaked[_nodeOperator]);\n (bool success, bytes memory data) = _NodeAccount.call{value: _bond}('');\n if (!success) {\n revert LowLevelEthTransfer(success, data);\n }\n }\n\n /**\n * @notice Tops up the node operator's RPL stake if it falls below the target stake ratio.\n * @dev This function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it calculates the necessary RPL amount to\n * bring the stake ratio back to the target. Then, the function either stakes the required RPL or stakes\n * the remaining RPL balance if it's not enough.\n * @param _NodeAccount The address of the node.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n */\n function performTopUp(address _NodeAccount, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(\n _NodeAccount\n );\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n uint256 requiredStakeRpl = minuend < rplStaked ? 0 : minuend - rplStaked;\n // Make sure the contract has enough RPL to stake\n uint256 currentRplBalance = RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n if (currentRplBalance >= requiredStakeRpl) {\n if (requiredStakeRpl == 0) {\n return;\n }\n // stakeRPLOnBehalfOf\n // transfer RPL to deposit pool\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n requiredStakeRpl\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, requiredStakeRpl);\n } else {\n if (currentRplBalance == 0) {\n return;\n }\n // stake what we have\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n currentRplBalance\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, currentRplBalance);\n }\n }\n }\n\n function performTopDown(address _nodeAddress, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(_nodeAddress);\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n uint256 excessRpl = rplStaked > maxRplStake ? rplStaked - maxRplStake : 0;\n\n if (excessRpl > 0) {\n fundedRpl -= excessRpl;\n FundRouter(_directory.getDepositPoolAddress()).unstakeRpl(_nodeAddress, excessRpl);\n\n // Update the amount of RPL funded by the node\n minipoolAmountFundedRpl[_nodeAddress] -= excessRpl;\n }\n }\n }\n\n /**\n * @notice Calculates the amount of RPL needed to top up the node operator's stake to the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it returns the necessary RPL amount to\n * bring the stake ratio back to the target.\n * @param _existingRplStake Prior crap staked\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return requiredStakeRpl The amount of RPL required to top up to the target stake ratio.\n */\n function calculateRequiredRplTopUp(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 requiredStakeRpl) {\n console.log('before calling getPriceFetcherAddress');\n console.logAddress(getDirectory().getPriceFetcherAddress());\n console.log('B');\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n console.log('price', ethPriceInRpl);\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n requiredStakeRpl = minuend < _existingRplStake ? 0 : minuend - _existingRplStake;\n } else {\n requiredStakeRpl = 0;\n }\n return requiredStakeRpl;\n }\n\n /**\n * @notice Calculates the amount of RPL that can be withdrawn from the node operator's stake without falling below the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is above a predefined target, it returns the maximum RPL amount that can be withdrawn\n * while still maintaining at least the target stake ratio.\n * @param _existingRplStake The amount of RPL currently staked by the node operator.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return withdrawableStakeRpl The maximum amount of RPL that can be withdrawn while maintaining the target stake ratio.\n */\n function calculateRequiredRplTopDown(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 withdrawableStakeRpl) {\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n withdrawableStakeRpl = _existingRplStake > maxRplStake ? _existingRplStake - maxRplStake : 0;\n } else {\n withdrawableStakeRpl = 0;\n }\n return withdrawableStakeRpl;\n }\n\n /**\n * @notice Processes rewards for a predefined number of minipools. This function is meant to be called during\n * the creation of new intervals. It serves to withdraw rewards from minipools and to top up the RPL stake.\n * @dev The function first checks if there are any minipools to process. If there aren't, it emits a warning event\n * and exits. Otherwise, it calls the internal function _processNextMinipool() for a certain number of times defined\n * by numMinipoolsProcessedPerInterval.\n */\n function processNextMinipool() external onlyProtocol {\n if (minipoolAddresses.length == 0) {\n emit WarningNoMiniPoolsToHarvest();\n return;\n }\n\n for (uint i = 0; i < numMinipoolsProcessedPerInterval; i++) {\n _processNextMinipool();\n }\n }\n\n function OnMinipoolCreated(address newMinipoolAddress, address nodeAddress, uint256 bond) external {\n if (!_directory.hasRole(Constants.CORE_PROTOCOL_ROLE, msg.sender)) {\n revert BadRole(Constants.CORE_PROTOCOL_ROLE, msg.sender);\n }\n\n // register minipool with node operator\n Whitelist whitelist = Whitelist(getDirectory().getWhitelistAddress());\n whitelist.registerNewValidator(nodeAddress);\n\n // new minipool owned by node operator\n nodeOperatorOwnedMinipools[nodeAddress].push(newMinipoolAddress);\n\n // add minipool to minipoolAddresses\n minipoolAddresses.push(newMinipoolAddress);\n minipoolIndexMap[newMinipoolAddress] = minipoolAddresses.length;\n\n emit MinipoolCreated(newMinipoolAddress, nodeAddress);\n\n // updated amount funded eth\n minipoolAmountFundedEth[newMinipoolAddress] = bond;\n }\n\n /**\n * @dev Processes a single minipool by performing RPL top-up and distributing balance if certain conditions are met.\n */\n function _processNextMinipool() internal {\n uint256 index = nextMinipoolHavestIndex % minipoolAddresses.length;\n IMinipool minipool = IMinipool(minipoolAddresses[index]);\n\n if (minipool.getStatus() != MinipoolStatus.Staking) {\n emit WarningMinipoolNotStaking(address(minipool), minipool.getStatus());\n return;\n }\n\n // process top up\n address nodeAddress = minipool.getNodeAddress();\n\n uint256 ethStaked = nodeOperatorEthStaked[nodeAddress];\n\n performTopUp(nodeAddress, ethStaked);\n performTopDown(nodeAddress, ethStaked);\n\n nextMinipoolHavestIndex = index + 1;\n\n uint256 balance = minipool.getNodeDepositBalance();\n minipool.distributeBalance(balance >= 8 ether);\n }\n\n /**\n * @notice Set the number of minipools to be processed per interval.\n * @dev This function can only be called by the contract's admin.\n * Adjusting this parameter allows the admin to control and optimize the load\n * on the network for each interval, especially in scenarios with a large number of minipools.\n * @param _numMinipoolsProcessedPerInterval The new number of minipools to process per interval.\n */\n function setNumMinipoolsProcessedPerInterval(uint256 _numMinipoolsProcessedPerInterval) external onlyAdmin {\n numMinipoolsProcessedPerInterval = _numMinipoolsProcessedPerInterval;\n }\n\n function setBondRequirments(uint256 _requiredLEBStaked) external onlyAdmin {\n requiredLEBStaked = _requiredLEBStaked;\n }\n\n function onNodeOperatorDissolved(address _nodeOperator, uint256 _bond) external onlyProtocol {\n fundedEth -= _bond;\n nodeOperatorEthStaked[_nodeOperator] -= _bond;\n }\n\n /**\n * @notice Retrieves the list of minipool addresses managed by the contract.\n * @dev This function provides a way to fetch all the current minipool addresses in memory.\n * Useful for off-chain services or frontend interfaces that need to display or interact\n * with the various minipools.\n * @return A list of addresses corresponding to the minipools.\n */\n function getMinipoolAddresses() external view returns (address[] memory) {\n return minipoolAddresses;\n }\n\n function transferWEthToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getWETHVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n address weth = _directory.getWETHAddress();\n\n // Check if there's enough WETH in the contract\n uint256 wethBalance = IWETH(weth).balanceOf(address(this));\n if (wethBalance >= _amount) {\n IWETH(weth).deposit{value: _amount}();\n SafeERC20.safeTransfer(IERC20(weth), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n\n function transferRplToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getRPLVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n\n // Check if there's enough RPL in the contract\n address rpl = IERC4626Upgradeable(vault).asset();\n uint256 rplBalance = IERC20(rpl).balanceOf(address(this));\n if (rplBalance >= _amount) {\n SafeERC20.safeTransfer(IERC20(rpl), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n}\n","line":82,"range":[3167,3206]},"functionType":3},{"type":2,"address":{"type":"Buffer","data":[38,46,43,80,33,150,32,34,108,95,181,149,100,50,168,143,255,217,75,167]}},{"type":0,"sourceReference":{"function":"sendEthToDistributors","contract":"FundRouter","sourceName":"contracts/FundRouter.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/Strings.sol';\n\nimport './UpgradeableBase.sol';\nimport './Operator/OperatorDistributor.sol';\nimport './Operator/YieldDistributor.sol';\nimport './Interfaces/RocketPool/IRocketNodeStaking.sol';\nimport './Tokens/WETHVault.sol';\nimport './Tokens/RPLVault.sol';\n\nimport './Interfaces/IWETH.sol';\nimport './Utils/Constants.sol';\n\n/// @custom:security-contact info@nodeoperator.org\n/// @notice Immutable deposit pool which holds deposits and provides a minimum source of liquidity for depositors.\n/// ETH + RPL intakes from token mints and validator yields and sends to respective ERC4246 vaults.\ncontract FundRouter is UpgradeableBase {\n constructor() initializer {}\n\n /// @dev Initializes the FundRouter contract with the specified directory address.\n /// @param directoryAddress The address of the directory contract.\n function initialize(address directoryAddress) public virtual override initializer {\n super.initialize(directoryAddress);\n }\n\n ///--------\n /// GETTERS\n ///--------\n\n /// @notice Retrieves the total ETH and WETH value locked inside this deposit pool.\n /// @dev This function calculates and returns the combined value of ETH and WETH held by the deposit pool.\n /// It sums the ETH balance of this contract and the WETH balance from the WETH contract.\n /// @return The total value in ETH and WETH locked in the deposit pool.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + IWETH(_directory.getWETHAddress()).balanceOf(address(this));\n }\n\n /// @notice Retrieves the total RPL value locked inside this deposit pool.\n /// @dev This function calculates and returns the total amount of RPL tokens held by the deposit pool.\n /// @return The total value in RPL locked in the deposit pool.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n }\n\n ///--------\n /// ACTIONS\n ///--------\n\n /// @notice Unstakes a specified amount of RPL tokens.\n /// @dev This function allows an administrator to unstake a specified amount of RPL tokens from the Rocket Node Staking contract.\n /// @param _excessRpl The amount of RPL tokens to unstake.\n /// @dev The tokens will be withdrawn from the Rocket Node Staking contract.\n function unstakeRpl(address _nodeAddress, uint256 _excessRpl) external onlyAdmin {\n IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress()).withdrawRPL(_nodeAddress, _excessRpl);\n }\n\n /// @notice Stakes a specified amount of RPL tokens on behalf of a node operator.\n /// @dev This function allows the protocol or an administrator to stake a specified amount of RPL tokens on behalf of a node operator\n /// using the Rocket Node Staking contract.\n /// @param _nodeAddress The address of the node operator on whose behalf the RPL tokens are being staked.\n /// @param _amount The amount of RPL tokens to stake.\n /// @dev This function ensures that the specified amount of RPL tokens is approved and then staked for the given node operator.\n function stakeRPLFor(address _nodeAddress, uint256 _amount) external onlyProtocolOrAdmin {\n SafeERC20.safeApprove(\n RocketTokenRPLInterface(_directory.getRPLAddress()),\n _directory.getRocketNodeStakingAddress(),\n 0\n );\n SafeERC20.safeApprove(\n RocketTokenRPLInterface(_directory.getRPLAddress()),\n _directory.getRocketNodeStakingAddress(),\n _amount\n );\n IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).stakeRPLFor(_nodeAddress, _amount);\n }\n\n function sendEthToDistributors() public {\n console.log('sendEthToDistributors.A');\n // Convert entire WETH balance of this contract to ETH\n IWETH WETH = IWETH(_directory.getWETHAddress());\n uint256 wethBalance = WETH.balanceOf(address(this));\n WETH.withdraw(wethBalance);\n console.log('sendEthToDistributors.B');\n\n // Initialize the vault and operator distributor addresses\n WETHVault vweth = WETHVault(getDirectory().getWETHVaultAddress());\n address payable operatorDistributor = payable(getDirectory().getOperatorDistributorAddress());\n console.log('sendEthToDistributors.C');\n\n // Calculate required capital and total balance\n uint256 requiredCapital = vweth.getRequiredCollateral();\n uint256 ethBalance = address(this).balance;\n console.log('sendEthToDistributors.D');\n\n if (ethBalance >= requiredCapital) {\n console.log('sendEthToDistributors.E');\n\n // Send required capital in WETH to vault and surplus ETH to operator distributor\n WETH.deposit{value: requiredCapital}();\n console.log('sendEthToDistributors.E1');\n\n SafeERC20.safeTransfer(WETH, address(vweth), requiredCapital);\n console.log('sendEthToDistributors.E2');\n\n uint256 surplus = ethBalance - requiredCapital;\n console.log('sendEthToDistributors.E3');\n\n operatorDistributor.transfer(surplus);\n console.log('sendEthToDistributors.F');\n } else {\n console.log('sendEthToDistributors.G');\n\n // If not enough ETH balance, convert the shortfall in WETH back to ETH and send it\n uint256 shortfall = requiredCapital - ethBalance;\n WETH.deposit{value: shortfall}();\n SafeERC20.safeTransfer(IERC20(address(WETH)), address(vweth), requiredCapital);\n console.log('sendEthToDistributors.H');\n }\n console.log('sendEthToDistributors.I');\n }\n\n function sendRplToDistributors() public {\n console.log('sendRplToDistributors.A');\n\n // Initialize the RPLVault and the Operator Distributor addresses\n RPLVault vrpl = RPLVault(getDirectory().getRPLVaultAddress());\n address operatorDistributor = getDirectory().getOperatorDistributorAddress();\n RocketTokenRPLInterface RPL = RocketTokenRPLInterface(_directory.getRPLAddress());\n console.log('sendRplToDistributors.B');\n\n // Fetch the required capital in RPL and the total RPL balance of the contract\n uint256 requiredCapital = vrpl.getRequiredCollateral();\n uint256 totalBalance = RPL.balanceOf(address(this));\n console.log('sendRplToDistributors.C');\n\n // Determine the amount to send to the RPLVault\n uint256 toRplVault = (totalBalance >= requiredCapital) ? requiredCapital : totalBalance;\n console.log('sendRplToDistributors.D');\n\n // Transfer RPL to the RPLVault\n if (toRplVault > 0) {\n console.log('sendRplToDistributors.E');\n\n SafeERC20.safeTransfer(IERC20(address(RPL)), address(vrpl), toRplVault);\n }\n\n // Transfer any surplus RPL to the Operator Distributor\n if (totalBalance > toRplVault) {\n console.log('sendRplToDistributors.F');\n\n SafeERC20.safeTransfer(IERC20(address(RPL)), operatorDistributor, totalBalance - toRplVault);\n }\n console.log('sendRplToDistributors.G');\n }\n\n /// @notice Receive hook for ETH deposits.\n /// @dev This function allows the contract to receive ETH deposits sent to its address.\n /// It is used as a fallback function to accept incoming ETH transfers.\n receive() external payable {}\n}\n","line":110,"range":[5213,5250]},"functionType":1},{"type":2,"address":{"type":"Buffer","data":[16,227,142,233,221,76,84,155,97,64,15,193,147,71,208,14,211,237,175,196]}},{"type":0,"sourceReference":{"function":"","contract":"OperatorDistributor","sourceName":"contracts/Operator/OperatorDistributor.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';\n\nimport '../UpgradeableBase.sol';\nimport '../Whitelist/Whitelist.sol';\nimport '../FundRouter.sol';\nimport '../PriceFetcher.sol';\nimport '../Tokens/WETHVault.sol';\n\nimport '../Utils/Constants.sol';\nimport '../Utils/Errors.sol';\n\nimport '../Interfaces/IWETH.sol';\nimport '../Interfaces/RocketPool/IRocketStorage.sol';\nimport '../Interfaces/RocketPool/IMinipool.sol';\nimport '../Interfaces/RocketPool/IRocketNodeManager.sol';\nimport '../Interfaces/RocketPool/IRocketNodeStaking.sol';\n\ncontract OperatorDistributor is UpgradeableBase, Errors {\n event MinipoolCreated(address indexed _minipoolAddress, address indexed _nodeAddress);\n event MinipoolDestroyed(address indexed _minipoolAddress, address indexed _nodeAddress);\n event WarningNoMiniPoolsToHarvest();\n event WarningMinipoolNotStaking(address indexed _minipoolAddress, MinipoolStatus indexed _status);\n\n using Math for uint256;\n\n // The total amount of Ether (ETH) funded or allocated by the contract.\n // This variable keeps track of the ETH resources managed within this contract,\n uint256 public fundedEth;\n\n // The total amount of Rocket Pool tokens (RPL) funded or allocated by the contract.\n // This field is used to track the RPL token balance managed by the contract,\n uint256 public fundedRpl;\n\n address[] public minipoolAddresses;\n\n uint256 public nextMinipoolHavestIndex;\n uint256 public targetStakeRatio;\n\n uint256 public numMinipoolsProcessedPerInterval;\n\n uint256 public requiredLEBStaked;\n\n mapping(address => uint256) public minipoolIndexMap;\n mapping(address => uint256) public minipoolAmountFundedEth;\n mapping(address => uint256) public minipoolAmountFundedRpl;\n\n mapping(address => address[]) public nodeOperatorOwnedMinipools;\n mapping(address => uint256) public nodeOperatorEthStaked;\n\n constructor() initializer {}\n\n /**\n * @notice Initializes the contract with the provided storage address.\n * @dev This function should only be called once, during contract creation or proxy initialization.\n * It overrides the `initialize` function from a parent contract.\n * @param _directory The address of the storage contract.\n */\n function initialize(address _directory) public override initializer {\n super.initialize(_directory);\n targetStakeRatio = 1.5e18; // 150%\n numMinipoolsProcessedPerInterval = 1;\n\n // defaulting these to 8eth to only allow LEB8 minipools\n requiredLEBStaked = 8 ether;\n }\n\n /**\n * @notice Receives incoming Ether and adds it to the queued balance.\n * @dev This is the fallback function that is called when Ether is sent directly to the contract.\n */\n receive() external payable {\n address payable dp = _directory.getDepositPoolAddress();\n console.log('fallback od initial');\n console.log(address(this).balance);\n\n if (msg.sender != dp) {\n (bool success, ) = dp.call{value: msg.value}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n }\n\n console.log('fallback od final');\n console.log(address(this).balance);\n }\n\n function _rebalanceLiquidity() internal nonReentrant {\n address payable dp = _directory.getDepositPoolAddress();\n (bool success, ) = dp.call{value: address(this).balance}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n\n IERC20 rpl = IERC20(_directory.getRPLAddress());\n SafeERC20.safeTransfer(rpl, dp, rpl.balanceOf(address(this)));\n FundRouter(dp).sendRplToDistributors();\n }\n\n /// @notice Gets the total ETH value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function sums up the balance of this contract with the amount of funded ETH across all minipools.\n /// Ensure that all sources of ETH (like the OperatorDistributor) are properly accounted for in the calculation.\n /// @return The total amount of Ether locked inside the protocol.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + fundedEth;\n }\n\n /// @notice Gets the total RPL value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function calculates the total RPL by summing up the balance of RPL tokens of this contract\n /// with the amount of funded RPL across all minipools. It retrieves the RPL token address from the `_directory` contract.\n /// Ensure that all sources of RPL (like the OperatorDistributor) are accurately accounted for.\n /// @return The total amount of RPL tokens locked inside the protocol.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this)) + fundedRpl;\n }\n\n /**\n * @notice Removes a minipool address from the tracked list when a node operator exits.\n * @dev This function efficiently reorders the minipool addresses array and updates the index map.\n * It then resets the funded amount of ETH and RPL tokens for the removed minipool.\n * Should only be called by authorized protocol actors or admin.\n * @param _address The address of the minipool to be removed.\n *\n * Emits a `MinipoolDestroyed` event upon successful removal.\n */ function removeMinipoolAddress(address _address) public onlyProtocolOrAdmin {\n uint index = minipoolIndexMap[_address] - 1;\n require(index < minipoolAddresses.length, 'Address not found.');\n\n // Move the last address into the spot located by index\n address lastAddress = minipoolAddresses[minipoolAddresses.length - 1];\n minipoolAddresses[index] = lastAddress;\n minipoolIndexMap[lastAddress] = index;\n\n // Remove the last address\n minipoolAddresses.pop();\n delete minipoolIndexMap[_address];\n\n // Set amount funded to 0 since it's being returned to DP\n minipoolAmountFundedEth[_address] = 0;\n minipoolAmountFundedRpl[_address] = 0;\n\n emit MinipoolDestroyed(_address, IMinipool(_address).getNodeAddress());\n }\n\n /**\n * @notice Removes a node operator and all associated minipools.\n * @dev Iterates through all minipools owned by the node operator and removes them.\n * This action cannot be reversed, so it should be executed with caution.\n * Only authorized protocol actors or admin can call this function.\n * @param _address The address of the node operator to be removed.\n */\n function removeNodeOperator(address _address) external onlyProtocolOrAdmin {\n // remove all minipools owned by node operator\n address[] memory minipools = nodeOperatorOwnedMinipools[_address];\n for (uint i = 0; i < minipools.length; i++) {\n removeMinipoolAddress(minipools[i]);\n }\n delete nodeOperatorOwnedMinipools[_address];\n }\n\n /**\n * @notice Stakes the minimum required RPL tokens on behalf of a node.\n * @dev This function first fetches the node's minimum RPL stake requirement,\n * approves the Node Staking contract to spend the RPL, and then stakes the RPL for the node.\n * It assumes that the contract already holds enough RPL tokens for the staking process.\n * @param _nodeAddress The address of the node for which RPL should be staked.\n */\n function _stakeRPLFor(address _nodeAddress) internal {\n IRocketNodeStaking nodeStaking = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress());\n uint256 minimumRplStake = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress())\n .getNodeMinimumRPLStake(_nodeAddress);\n\n fundedRpl += minimumRplStake;\n\n // approve the node staking contract to spend the RPL\n RocketTokenRPLInterface rpl = RocketTokenRPLInterface(_directory.getRPLAddress());\n require(rpl.approve(getDirectory().getRocketNodeStakingAddress(), minimumRplStake));\n\n // update amount funded rpl\n minipoolAmountFundedRpl[_nodeAddress] = minimumRplStake;\n\n nodeStaking.stakeRPLFor(_nodeAddress, minimumRplStake);\n }\n\n /**\n * @notice Prepares a node for minipool creation by setting up necessary staking and validations.\n * @dev This function first validates the node's withdrawal address, then calculates the required amount of\n * RPL to stake based on the number of validators associated with the node, and performs a top-up.\n * Only the protocol or admin can call this function.\n * @param _NodeAccount The address of the validator account belonging to the Node Operator\n */\n function provisionLiquiditiesForMinipoolCreation(\n address _nodeOperator,\n address _NodeAccount,\n uint256 _bond\n ) external onlyProtocolOrAdmin {\n _rebalanceLiquidity();\n require(_bond == requiredLEBStaked, 'OperatorDistributor: Bad _bond amount, should be `requiredLEBStaked`');\n fundedEth += _bond;\n nodeOperatorEthStaked[_nodeOperator] += _bond;\n\n // by default this bonds 150% of stake according to max stake defined here: https://docs.rocketpool.net/guides/node/create-validator#staking-rpl\n // performTopUp(_NodeAccount, nodeOperatorEthStaked[_nodeOperator]);\n (bool success, bytes memory data) = _NodeAccount.call{value: _bond}('');\n if (!success) {\n revert LowLevelEthTransfer(success, data);\n }\n }\n\n /**\n * @notice Tops up the node operator's RPL stake if it falls below the target stake ratio.\n * @dev This function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it calculates the necessary RPL amount to\n * bring the stake ratio back to the target. Then, the function either stakes the required RPL or stakes\n * the remaining RPL balance if it's not enough.\n * @param _NodeAccount The address of the node.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n */\n function performTopUp(address _NodeAccount, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(\n _NodeAccount\n );\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n uint256 requiredStakeRpl = minuend < rplStaked ? 0 : minuend - rplStaked;\n // Make sure the contract has enough RPL to stake\n uint256 currentRplBalance = RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n if (currentRplBalance >= requiredStakeRpl) {\n if (requiredStakeRpl == 0) {\n return;\n }\n // stakeRPLOnBehalfOf\n // transfer RPL to deposit pool\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n requiredStakeRpl\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, requiredStakeRpl);\n } else {\n if (currentRplBalance == 0) {\n return;\n }\n // stake what we have\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n currentRplBalance\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, currentRplBalance);\n }\n }\n }\n\n function performTopDown(address _nodeAddress, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(_nodeAddress);\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n uint256 excessRpl = rplStaked > maxRplStake ? rplStaked - maxRplStake : 0;\n\n if (excessRpl > 0) {\n fundedRpl -= excessRpl;\n FundRouter(_directory.getDepositPoolAddress()).unstakeRpl(_nodeAddress, excessRpl);\n\n // Update the amount of RPL funded by the node\n minipoolAmountFundedRpl[_nodeAddress] -= excessRpl;\n }\n }\n }\n\n /**\n * @notice Calculates the amount of RPL needed to top up the node operator's stake to the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it returns the necessary RPL amount to\n * bring the stake ratio back to the target.\n * @param _existingRplStake Prior crap staked\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return requiredStakeRpl The amount of RPL required to top up to the target stake ratio.\n */\n function calculateRequiredRplTopUp(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 requiredStakeRpl) {\n console.log('before calling getPriceFetcherAddress');\n console.logAddress(getDirectory().getPriceFetcherAddress());\n console.log('B');\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n console.log('price', ethPriceInRpl);\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n requiredStakeRpl = minuend < _existingRplStake ? 0 : minuend - _existingRplStake;\n } else {\n requiredStakeRpl = 0;\n }\n return requiredStakeRpl;\n }\n\n /**\n * @notice Calculates the amount of RPL that can be withdrawn from the node operator's stake without falling below the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is above a predefined target, it returns the maximum RPL amount that can be withdrawn\n * while still maintaining at least the target stake ratio.\n * @param _existingRplStake The amount of RPL currently staked by the node operator.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return withdrawableStakeRpl The maximum amount of RPL that can be withdrawn while maintaining the target stake ratio.\n */\n function calculateRequiredRplTopDown(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 withdrawableStakeRpl) {\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n withdrawableStakeRpl = _existingRplStake > maxRplStake ? _existingRplStake - maxRplStake : 0;\n } else {\n withdrawableStakeRpl = 0;\n }\n return withdrawableStakeRpl;\n }\n\n /**\n * @notice Processes rewards for a predefined number of minipools. This function is meant to be called during\n * the creation of new intervals. It serves to withdraw rewards from minipools and to top up the RPL stake.\n * @dev The function first checks if there are any minipools to process. If there aren't, it emits a warning event\n * and exits. Otherwise, it calls the internal function _processNextMinipool() for a certain number of times defined\n * by numMinipoolsProcessedPerInterval.\n */\n function processNextMinipool() external onlyProtocol {\n if (minipoolAddresses.length == 0) {\n emit WarningNoMiniPoolsToHarvest();\n return;\n }\n\n for (uint i = 0; i < numMinipoolsProcessedPerInterval; i++) {\n _processNextMinipool();\n }\n }\n\n function OnMinipoolCreated(address newMinipoolAddress, address nodeAddress, uint256 bond) external {\n if (!_directory.hasRole(Constants.CORE_PROTOCOL_ROLE, msg.sender)) {\n revert BadRole(Constants.CORE_PROTOCOL_ROLE, msg.sender);\n }\n\n // register minipool with node operator\n Whitelist whitelist = Whitelist(getDirectory().getWhitelistAddress());\n whitelist.registerNewValidator(nodeAddress);\n\n // new minipool owned by node operator\n nodeOperatorOwnedMinipools[nodeAddress].push(newMinipoolAddress);\n\n // add minipool to minipoolAddresses\n minipoolAddresses.push(newMinipoolAddress);\n minipoolIndexMap[newMinipoolAddress] = minipoolAddresses.length;\n\n emit MinipoolCreated(newMinipoolAddress, nodeAddress);\n\n // updated amount funded eth\n minipoolAmountFundedEth[newMinipoolAddress] = bond;\n }\n\n /**\n * @dev Processes a single minipool by performing RPL top-up and distributing balance if certain conditions are met.\n */\n function _processNextMinipool() internal {\n uint256 index = nextMinipoolHavestIndex % minipoolAddresses.length;\n IMinipool minipool = IMinipool(minipoolAddresses[index]);\n\n if (minipool.getStatus() != MinipoolStatus.Staking) {\n emit WarningMinipoolNotStaking(address(minipool), minipool.getStatus());\n return;\n }\n\n // process top up\n address nodeAddress = minipool.getNodeAddress();\n\n uint256 ethStaked = nodeOperatorEthStaked[nodeAddress];\n\n performTopUp(nodeAddress, ethStaked);\n performTopDown(nodeAddress, ethStaked);\n\n nextMinipoolHavestIndex = index + 1;\n\n uint256 balance = minipool.getNodeDepositBalance();\n minipool.distributeBalance(balance >= 8 ether);\n }\n\n /**\n * @notice Set the number of minipools to be processed per interval.\n * @dev This function can only be called by the contract's admin.\n * Adjusting this parameter allows the admin to control and optimize the load\n * on the network for each interval, especially in scenarios with a large number of minipools.\n * @param _numMinipoolsProcessedPerInterval The new number of minipools to process per interval.\n */\n function setNumMinipoolsProcessedPerInterval(uint256 _numMinipoolsProcessedPerInterval) external onlyAdmin {\n numMinipoolsProcessedPerInterval = _numMinipoolsProcessedPerInterval;\n }\n\n function setBondRequirments(uint256 _requiredLEBStaked) external onlyAdmin {\n requiredLEBStaked = _requiredLEBStaked;\n }\n\n function onNodeOperatorDissolved(address _nodeOperator, uint256 _bond) external onlyProtocol {\n fundedEth -= _bond;\n nodeOperatorEthStaked[_nodeOperator] -= _bond;\n }\n\n /**\n * @notice Retrieves the list of minipool addresses managed by the contract.\n * @dev This function provides a way to fetch all the current minipool addresses in memory.\n * Useful for off-chain services or frontend interfaces that need to display or interact\n * with the various minipools.\n * @return A list of addresses corresponding to the minipools.\n */\n function getMinipoolAddresses() external view returns (address[] memory) {\n return minipoolAddresses;\n }\n\n function transferWEthToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getWETHVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n address weth = _directory.getWETHAddress();\n\n // Check if there's enough WETH in the contract\n uint256 wethBalance = IWETH(weth).balanceOf(address(this));\n if (wethBalance >= _amount) {\n IWETH(weth).deposit{value: _amount}();\n SafeERC20.safeTransfer(IERC20(weth), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n\n function transferRplToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getRPLVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n\n // Check if there's enough RPL in the contract\n address rpl = IERC4626Upgradeable(vault).asset();\n uint256 rplBalance = IERC20(rpl).balanceOf(address(this));\n if (rplBalance >= _amount) {\n SafeERC20.safeTransfer(IERC20(rpl), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n}\n","line":76,"range":[2919,2953]},"functionType":3},{"type":23,"sourceReference":{"function":"log","contract":"OperatorDistributor","sourceName":"hardhat/console.sol","sourceContent":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n\n}\n","line":197,"range":[6141,6183]}}],"data":"0x"}, code=UNPREDICTABLE_GAS_LIMIT, version=providers/5.7.2) + Error: cannot estimate gas; transaction may fail or may require manual gas limit [ See: https://links.ethers.org/v5-errors-UNPREDICTABLE_GAS_LIMIT ] (reason="Transaction reverted: contract call run out of gas and made the transaction revert", method="estimateGas", transaction={"from":"0x1CBd3b2770909D4e10f157cABC84C7264073C9Ec","to":"0x10e38eE9dd4C549b61400Fc19347D00eD3edAfC4","value":{"type":"BigNumber","hex":"0x6f05b59d3b200000"},"accessList":null}, error={"stackTrace":[{"type":2,"address":{"type":"Buffer","data":[16,227,142,233,221,76,84,155,97,64,15,193,147,71,208,14,211,237,175,196]}},{"type":0,"sourceReference":{"function":"","contract":"OperatorDistributor","sourceName":"contracts/Operator/OperatorDistributor.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';\n\nimport '../UpgradeableBase.sol';\nimport '../Whitelist/Whitelist.sol';\nimport '../FundRouter.sol';\nimport '../PriceFetcher.sol';\nimport '../Tokens/WETHVault.sol';\n\nimport '../Utils/Constants.sol';\nimport '../Utils/Errors.sol';\n\nimport '../Interfaces/IWETH.sol';\nimport '../Interfaces/RocketPool/IRocketStorage.sol';\nimport '../Interfaces/RocketPool/IMinipool.sol';\nimport '../Interfaces/RocketPool/IRocketNodeManager.sol';\nimport '../Interfaces/RocketPool/IRocketNodeStaking.sol';\n\ncontract OperatorDistributor is UpgradeableBase, Errors {\n event MinipoolCreated(address indexed _minipoolAddress, address indexed _nodeAddress);\n event MinipoolDestroyed(address indexed _minipoolAddress, address indexed _nodeAddress);\n event WarningNoMiniPoolsToHarvest();\n event WarningMinipoolNotStaking(address indexed _minipoolAddress, MinipoolStatus indexed _status);\n\n using Math for uint256;\n\n // The total amount of Ether (ETH) funded or allocated by the contract.\n // This variable keeps track of the ETH resources managed within this contract,\n uint256 public fundedEth;\n\n // The total amount of Rocket Pool tokens (RPL) funded or allocated by the contract.\n // This field is used to track the RPL token balance managed by the contract,\n uint256 public fundedRpl;\n\n address[] public minipoolAddresses;\n\n uint256 public nextMinipoolHavestIndex;\n uint256 public targetStakeRatio;\n\n uint256 public numMinipoolsProcessedPerInterval;\n\n uint256 public requiredLEBStaked;\n\n mapping(address => uint256) public minipoolIndexMap;\n mapping(address => uint256) public minipoolAmountFundedEth;\n mapping(address => uint256) public minipoolAmountFundedRpl;\n\n mapping(address => address[]) public nodeOperatorOwnedMinipools;\n mapping(address => uint256) public nodeOperatorEthStaked;\n\n constructor() initializer {}\n\n /**\n * @notice Initializes the contract with the provided storage address.\n * @dev This function should only be called once, during contract creation or proxy initialization.\n * It overrides the `initialize` function from a parent contract.\n * @param _directory The address of the storage contract.\n */\n function initialize(address _directory) public override initializer {\n super.initialize(_directory);\n targetStakeRatio = 1.5e18; // 150%\n numMinipoolsProcessedPerInterval = 1;\n\n // defaulting these to 8eth to only allow LEB8 minipools\n requiredLEBStaked = 8 ether;\n }\n\n /**\n * @notice Receives incoming Ether and adds it to the queued balance.\n * @dev This is the fallback function that is called when Ether is sent directly to the contract.\n */\n receive() external payable {\n address payable dp = _directory.getDepositPoolAddress();\n console.log('fallback od initial');\n console.log(address(this).balance);\n\n if (msg.sender != dp) {\n (bool success, ) = dp.call{value: msg.value}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n }\n\n console.log('fallback od final');\n console.log(address(this).balance);\n }\n\n function _rebalanceLiquidity() internal nonReentrant {\n address payable dp = _directory.getDepositPoolAddress();\n (bool success, ) = dp.call{value: address(this).balance}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n\n IERC20 rpl = IERC20(_directory.getRPLAddress());\n SafeERC20.safeTransfer(rpl, dp, rpl.balanceOf(address(this)));\n FundRouter(dp).sendRplToDistributors();\n }\n\n /// @notice Gets the total ETH value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function sums up the balance of this contract with the amount of funded ETH across all minipools.\n /// Ensure that all sources of ETH (like the OperatorDistributor) are properly accounted for in the calculation.\n /// @return The total amount of Ether locked inside the protocol.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + fundedEth;\n }\n\n /// @notice Gets the total RPL value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function calculates the total RPL by summing up the balance of RPL tokens of this contract\n /// with the amount of funded RPL across all minipools. It retrieves the RPL token address from the `_directory` contract.\n /// Ensure that all sources of RPL (like the OperatorDistributor) are accurately accounted for.\n /// @return The total amount of RPL tokens locked inside the protocol.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this)) + fundedRpl;\n }\n\n /**\n * @notice Removes a minipool address from the tracked list when a node operator exits.\n * @dev This function efficiently reorders the minipool addresses array and updates the index map.\n * It then resets the funded amount of ETH and RPL tokens for the removed minipool.\n * Should only be called by authorized protocol actors or admin.\n * @param _address The address of the minipool to be removed.\n *\n * Emits a `MinipoolDestroyed` event upon successful removal.\n */ function removeMinipoolAddress(address _address) public onlyProtocolOrAdmin {\n uint index = minipoolIndexMap[_address] - 1;\n require(index < minipoolAddresses.length, 'Address not found.');\n\n // Move the last address into the spot located by index\n address lastAddress = minipoolAddresses[minipoolAddresses.length - 1];\n minipoolAddresses[index] = lastAddress;\n minipoolIndexMap[lastAddress] = index;\n\n // Remove the last address\n minipoolAddresses.pop();\n delete minipoolIndexMap[_address];\n\n // Set amount funded to 0 since it's being returned to DP\n minipoolAmountFundedEth[_address] = 0;\n minipoolAmountFundedRpl[_address] = 0;\n\n emit MinipoolDestroyed(_address, IMinipool(_address).getNodeAddress());\n }\n\n /**\n * @notice Removes a node operator and all associated minipools.\n * @dev Iterates through all minipools owned by the node operator and removes them.\n * This action cannot be reversed, so it should be executed with caution.\n * Only authorized protocol actors or admin can call this function.\n * @param _address The address of the node operator to be removed.\n */\n function removeNodeOperator(address _address) external onlyProtocolOrAdmin {\n // remove all minipools owned by node operator\n address[] memory minipools = nodeOperatorOwnedMinipools[_address];\n for (uint i = 0; i < minipools.length; i++) {\n removeMinipoolAddress(minipools[i]);\n }\n delete nodeOperatorOwnedMinipools[_address];\n }\n\n /**\n * @notice Stakes the minimum required RPL tokens on behalf of a node.\n * @dev This function first fetches the node's minimum RPL stake requirement,\n * approves the Node Staking contract to spend the RPL, and then stakes the RPL for the node.\n * It assumes that the contract already holds enough RPL tokens for the staking process.\n * @param _nodeAddress The address of the node for which RPL should be staked.\n */\n function _stakeRPLFor(address _nodeAddress) internal {\n IRocketNodeStaking nodeStaking = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress());\n uint256 minimumRplStake = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress())\n .getNodeMinimumRPLStake(_nodeAddress);\n\n fundedRpl += minimumRplStake;\n\n // approve the node staking contract to spend the RPL\n RocketTokenRPLInterface rpl = RocketTokenRPLInterface(_directory.getRPLAddress());\n require(rpl.approve(getDirectory().getRocketNodeStakingAddress(), minimumRplStake));\n\n // update amount funded rpl\n minipoolAmountFundedRpl[_nodeAddress] = minimumRplStake;\n\n nodeStaking.stakeRPLFor(_nodeAddress, minimumRplStake);\n }\n\n /**\n * @notice Prepares a node for minipool creation by setting up necessary staking and validations.\n * @dev This function first validates the node's withdrawal address, then calculates the required amount of\n * RPL to stake based on the number of validators associated with the node, and performs a top-up.\n * Only the protocol or admin can call this function.\n * @param _NodeAccount The address of the validator account belonging to the Node Operator\n */\n function provisionLiquiditiesForMinipoolCreation(\n address _nodeOperator,\n address _NodeAccount,\n uint256 _bond\n ) external onlyProtocolOrAdmin {\n _rebalanceLiquidity();\n require(_bond == requiredLEBStaked, 'OperatorDistributor: Bad _bond amount, should be `requiredLEBStaked`');\n fundedEth += _bond;\n nodeOperatorEthStaked[_nodeOperator] += _bond;\n\n // by default this bonds 150% of stake according to max stake defined here: https://docs.rocketpool.net/guides/node/create-validator#staking-rpl\n // performTopUp(_NodeAccount, nodeOperatorEthStaked[_nodeOperator]);\n (bool success, bytes memory data) = _NodeAccount.call{value: _bond}('');\n if (!success) {\n revert LowLevelEthTransfer(success, data);\n }\n }\n\n /**\n * @notice Tops up the node operator's RPL stake if it falls below the target stake ratio.\n * @dev This function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it calculates the necessary RPL amount to\n * bring the stake ratio back to the target. Then, the function either stakes the required RPL or stakes\n * the remaining RPL balance if it's not enough.\n * @param _NodeAccount The address of the node.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n */\n function performTopUp(address _NodeAccount, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(\n _NodeAccount\n );\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n uint256 requiredStakeRpl = minuend < rplStaked ? 0 : minuend - rplStaked;\n // Make sure the contract has enough RPL to stake\n uint256 currentRplBalance = RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n if (currentRplBalance >= requiredStakeRpl) {\n if (requiredStakeRpl == 0) {\n return;\n }\n // stakeRPLOnBehalfOf\n // transfer RPL to deposit pool\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n requiredStakeRpl\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, requiredStakeRpl);\n } else {\n if (currentRplBalance == 0) {\n return;\n }\n // stake what we have\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n currentRplBalance\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, currentRplBalance);\n }\n }\n }\n\n function performTopDown(address _nodeAddress, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(_nodeAddress);\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n uint256 excessRpl = rplStaked > maxRplStake ? rplStaked - maxRplStake : 0;\n\n if (excessRpl > 0) {\n fundedRpl -= excessRpl;\n FundRouter(_directory.getDepositPoolAddress()).unstakeRpl(_nodeAddress, excessRpl);\n\n // Update the amount of RPL funded by the node\n minipoolAmountFundedRpl[_nodeAddress] -= excessRpl;\n }\n }\n }\n\n /**\n * @notice Calculates the amount of RPL needed to top up the node operator's stake to the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it returns the necessary RPL amount to\n * bring the stake ratio back to the target.\n * @param _existingRplStake Prior crap staked\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return requiredStakeRpl The amount of RPL required to top up to the target stake ratio.\n */\n function calculateRequiredRplTopUp(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 requiredStakeRpl) {\n console.log('before calling getPriceFetcherAddress');\n console.logAddress(getDirectory().getPriceFetcherAddress());\n console.log('B');\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n console.log('price', ethPriceInRpl);\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n requiredStakeRpl = minuend < _existingRplStake ? 0 : minuend - _existingRplStake;\n } else {\n requiredStakeRpl = 0;\n }\n return requiredStakeRpl;\n }\n\n /**\n * @notice Calculates the amount of RPL that can be withdrawn from the node operator's stake without falling below the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is above a predefined target, it returns the maximum RPL amount that can be withdrawn\n * while still maintaining at least the target stake ratio.\n * @param _existingRplStake The amount of RPL currently staked by the node operator.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return withdrawableStakeRpl The maximum amount of RPL that can be withdrawn while maintaining the target stake ratio.\n */\n function calculateRequiredRplTopDown(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 withdrawableStakeRpl) {\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n withdrawableStakeRpl = _existingRplStake > maxRplStake ? _existingRplStake - maxRplStake : 0;\n } else {\n withdrawableStakeRpl = 0;\n }\n return withdrawableStakeRpl;\n }\n\n /**\n * @notice Processes rewards for a predefined number of minipools. This function is meant to be called during\n * the creation of new intervals. It serves to withdraw rewards from minipools and to top up the RPL stake.\n * @dev The function first checks if there are any minipools to process. If there aren't, it emits a warning event\n * and exits. Otherwise, it calls the internal function _processNextMinipool() for a certain number of times defined\n * by numMinipoolsProcessedPerInterval.\n */\n function processNextMinipool() external onlyProtocol {\n if (minipoolAddresses.length == 0) {\n emit WarningNoMiniPoolsToHarvest();\n return;\n }\n\n for (uint i = 0; i < numMinipoolsProcessedPerInterval; i++) {\n _processNextMinipool();\n }\n }\n\n function OnMinipoolCreated(address newMinipoolAddress, address nodeAddress, uint256 bond) external {\n if (!_directory.hasRole(Constants.CORE_PROTOCOL_ROLE, msg.sender)) {\n revert BadRole(Constants.CORE_PROTOCOL_ROLE, msg.sender);\n }\n\n // register minipool with node operator\n Whitelist whitelist = Whitelist(getDirectory().getWhitelistAddress());\n whitelist.registerNewValidator(nodeAddress);\n\n // new minipool owned by node operator\n nodeOperatorOwnedMinipools[nodeAddress].push(newMinipoolAddress);\n\n // add minipool to minipoolAddresses\n minipoolAddresses.push(newMinipoolAddress);\n minipoolIndexMap[newMinipoolAddress] = minipoolAddresses.length;\n\n emit MinipoolCreated(newMinipoolAddress, nodeAddress);\n\n // updated amount funded eth\n minipoolAmountFundedEth[newMinipoolAddress] = bond;\n }\n\n /**\n * @dev Processes a single minipool by performing RPL top-up and distributing balance if certain conditions are met.\n */\n function _processNextMinipool() internal {\n uint256 index = nextMinipoolHavestIndex % minipoolAddresses.length;\n IMinipool minipool = IMinipool(minipoolAddresses[index]);\n\n if (minipool.getStatus() != MinipoolStatus.Staking) {\n emit WarningMinipoolNotStaking(address(minipool), minipool.getStatus());\n return;\n }\n\n // process top up\n address nodeAddress = minipool.getNodeAddress();\n\n uint256 ethStaked = nodeOperatorEthStaked[nodeAddress];\n\n performTopUp(nodeAddress, ethStaked);\n performTopDown(nodeAddress, ethStaked);\n\n nextMinipoolHavestIndex = index + 1;\n\n uint256 balance = minipool.getNodeDepositBalance();\n minipool.distributeBalance(balance >= 8 ether);\n }\n\n /**\n * @notice Set the number of minipools to be processed per interval.\n * @dev This function can only be called by the contract's admin.\n * Adjusting this parameter allows the admin to control and optimize the load\n * on the network for each interval, especially in scenarios with a large number of minipools.\n * @param _numMinipoolsProcessedPerInterval The new number of minipools to process per interval.\n */\n function setNumMinipoolsProcessedPerInterval(uint256 _numMinipoolsProcessedPerInterval) external onlyAdmin {\n numMinipoolsProcessedPerInterval = _numMinipoolsProcessedPerInterval;\n }\n\n function setBondRequirments(uint256 _requiredLEBStaked) external onlyAdmin {\n requiredLEBStaked = _requiredLEBStaked;\n }\n\n function onNodeMinipoolDestroy(address _nodeOperator, uint256 _bond) external onlyProtocol {\n fundedEth -= _bond;\n nodeOperatorEthStaked[_nodeOperator] -= _bond;\n }\n\n /**\n * @notice Retrieves the list of minipool addresses managed by the contract.\n * @dev This function provides a way to fetch all the current minipool addresses in memory.\n * Useful for off-chain services or frontend interfaces that need to display or interact\n * with the various minipools.\n * @return A list of addresses corresponding to the minipools.\n */\n function getMinipoolAddresses() external view returns (address[] memory) {\n return minipoolAddresses;\n }\n\n function transferWEthToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getWETHVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n address weth = _directory.getWETHAddress();\n\n // Check if there's enough WETH in the contract\n uint256 wethBalance = IWETH(weth).balanceOf(address(this));\n if (wethBalance >= _amount) {\n IWETH(weth).deposit{value: _amount}();\n SafeERC20.safeTransfer(IERC20(weth), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n\n function transferRplToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getRPLVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n\n // Check if there's enough RPL in the contract\n address rpl = IERC4626Upgradeable(vault).asset();\n uint256 rplBalance = IERC20(rpl).balanceOf(address(this));\n if (rplBalance >= _amount) {\n SafeERC20.safeTransfer(IERC20(rpl), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n}\n","line":82,"range":[3167,3206]},"functionType":3},{"type":2,"address":{"type":"Buffer","data":[38,46,43,80,33,150,32,34,108,95,181,149,100,50,168,143,255,217,75,167]}},{"type":0,"sourceReference":{"function":"sendEthToDistributors","contract":"FundRouter","sourceName":"contracts/FundRouter.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/Strings.sol';\n\nimport './UpgradeableBase.sol';\nimport './Operator/OperatorDistributor.sol';\nimport './Operator/YieldDistributor.sol';\nimport './Interfaces/RocketPool/IRocketNodeStaking.sol';\nimport './Tokens/WETHVault.sol';\nimport './Tokens/RPLVault.sol';\n\nimport './Interfaces/IWETH.sol';\nimport './Utils/Constants.sol';\n\n/// @custom:security-contact info@nodeoperator.org\n/// @notice Immutable deposit pool which holds deposits and provides a minimum source of liquidity for depositors.\n/// ETH + RPL intakes from token mints and validator yields and sends to respective ERC4246 vaults.\ncontract FundRouter is UpgradeableBase {\n constructor() initializer {}\n\n /// @dev Initializes the FundRouter contract with the specified directory address.\n /// @param directoryAddress The address of the directory contract.\n function initialize(address directoryAddress) public virtual override initializer {\n super.initialize(directoryAddress);\n }\n\n ///--------\n /// GETTERS\n ///--------\n\n /// @notice Retrieves the total ETH and WETH value locked inside this deposit pool.\n /// @dev This function calculates and returns the combined value of ETH and WETH held by the deposit pool.\n /// It sums the ETH balance of this contract and the WETH balance from the WETH contract.\n /// @return The total value in ETH and WETH locked in the deposit pool.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + IWETH(_directory.getWETHAddress()).balanceOf(address(this));\n }\n\n /// @notice Retrieves the total RPL value locked inside this deposit pool.\n /// @dev This function calculates and returns the total amount of RPL tokens held by the deposit pool.\n /// @return The total value in RPL locked in the deposit pool.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n }\n\n ///--------\n /// ACTIONS\n ///--------\n\n /// @notice Unstakes a specified amount of RPL tokens.\n /// @dev This function allows an administrator to unstake a specified amount of RPL tokens from the Rocket Node Staking contract.\n /// @param _excessRpl The amount of RPL tokens to unstake.\n /// @dev The tokens will be withdrawn from the Rocket Node Staking contract.\n function unstakeRpl(address _nodeAddress, uint256 _excessRpl) external onlyAdmin {\n IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress()).withdrawRPL(_nodeAddress, _excessRpl);\n }\n\n /// @notice Stakes a specified amount of RPL tokens on behalf of a node operator.\n /// @dev This function allows the protocol or an administrator to stake a specified amount of RPL tokens on behalf of a node operator\n /// using the Rocket Node Staking contract.\n /// @param _nodeAddress The address of the node operator on whose behalf the RPL tokens are being staked.\n /// @param _amount The amount of RPL tokens to stake.\n /// @dev This function ensures that the specified amount of RPL tokens is approved and then staked for the given node operator.\n function stakeRPLFor(address _nodeAddress, uint256 _amount) external onlyProtocolOrAdmin {\n SafeERC20.safeApprove(\n RocketTokenRPLInterface(_directory.getRPLAddress()),\n _directory.getRocketNodeStakingAddress(),\n 0\n );\n SafeERC20.safeApprove(\n RocketTokenRPLInterface(_directory.getRPLAddress()),\n _directory.getRocketNodeStakingAddress(),\n _amount\n );\n IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).stakeRPLFor(_nodeAddress, _amount);\n }\n\n function sendEthToDistributors() public {\n console.log('sendEthToDistributors.A');\n // Convert entire WETH balance of this contract to ETH\n IWETH WETH = IWETH(_directory.getWETHAddress());\n uint256 wethBalance = WETH.balanceOf(address(this));\n WETH.withdraw(wethBalance);\n console.log('sendEthToDistributors.B');\n\n // Initialize the vault and operator distributor addresses\n WETHVault vweth = WETHVault(getDirectory().getWETHVaultAddress());\n address payable operatorDistributor = payable(getDirectory().getOperatorDistributorAddress());\n console.log('sendEthToDistributors.C');\n\n // Calculate required capital and total balance\n uint256 requiredCapital = vweth.getRequiredCollateral();\n uint256 ethBalance = address(this).balance;\n console.log('sendEthToDistributors.D');\n\n if (ethBalance >= requiredCapital) {\n console.log('sendEthToDistributors.E');\n\n // Send required capital in WETH to vault and surplus ETH to operator distributor\n WETH.deposit{value: requiredCapital}();\n console.log('sendEthToDistributors.E1');\n\n SafeERC20.safeTransfer(WETH, address(vweth), requiredCapital);\n console.log('sendEthToDistributors.E2');\n\n uint256 surplus = ethBalance - requiredCapital;\n console.log('sendEthToDistributors.E3');\n\n operatorDistributor.transfer(surplus);\n console.log('sendEthToDistributors.F');\n } else {\n console.log('sendEthToDistributors.G');\n\n // If not enough ETH balance, convert the shortfall in WETH back to ETH and send it\n uint256 shortfall = requiredCapital - ethBalance;\n WETH.deposit{value: shortfall}();\n SafeERC20.safeTransfer(IERC20(address(WETH)), address(vweth), requiredCapital);\n console.log('sendEthToDistributors.H');\n }\n console.log('sendEthToDistributors.I');\n }\n\n function sendRplToDistributors() public {\n console.log('sendRplToDistributors.A');\n\n // Initialize the RPLVault and the Operator Distributor addresses\n RPLVault vrpl = RPLVault(getDirectory().getRPLVaultAddress());\n address operatorDistributor = getDirectory().getOperatorDistributorAddress();\n RocketTokenRPLInterface RPL = RocketTokenRPLInterface(_directory.getRPLAddress());\n console.log('sendRplToDistributors.B');\n\n // Fetch the required capital in RPL and the total RPL balance of the contract\n uint256 requiredCapital = vrpl.getRequiredCollateral();\n uint256 totalBalance = RPL.balanceOf(address(this));\n console.log('sendRplToDistributors.C');\n\n // Determine the amount to send to the RPLVault\n uint256 toRplVault = (totalBalance >= requiredCapital) ? requiredCapital : totalBalance;\n console.log('sendRplToDistributors.D');\n\n // Transfer RPL to the RPLVault\n if (toRplVault > 0) {\n console.log('sendRplToDistributors.E');\n\n SafeERC20.safeTransfer(IERC20(address(RPL)), address(vrpl), toRplVault);\n }\n\n // Transfer any surplus RPL to the Operator Distributor\n if (totalBalance > toRplVault) {\n console.log('sendRplToDistributors.F');\n\n SafeERC20.safeTransfer(IERC20(address(RPL)), operatorDistributor, totalBalance - toRplVault);\n }\n console.log('sendRplToDistributors.G');\n }\n\n /// @notice Receive hook for ETH deposits.\n /// @dev This function allows the contract to receive ETH deposits sent to its address.\n /// It is used as a fallback function to accept incoming ETH transfers.\n receive() external payable {}\n}\n","line":110,"range":[5213,5250]},"functionType":1},{"type":2,"address":{"type":"Buffer","data":[16,227,142,233,221,76,84,155,97,64,15,193,147,71,208,14,211,237,175,196]}},{"type":0,"sourceReference":{"function":"","contract":"OperatorDistributor","sourceName":"contracts/Operator/OperatorDistributor.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';\n\nimport '../UpgradeableBase.sol';\nimport '../Whitelist/Whitelist.sol';\nimport '../FundRouter.sol';\nimport '../PriceFetcher.sol';\nimport '../Tokens/WETHVault.sol';\n\nimport '../Utils/Constants.sol';\nimport '../Utils/Errors.sol';\n\nimport '../Interfaces/IWETH.sol';\nimport '../Interfaces/RocketPool/IRocketStorage.sol';\nimport '../Interfaces/RocketPool/IMinipool.sol';\nimport '../Interfaces/RocketPool/IRocketNodeManager.sol';\nimport '../Interfaces/RocketPool/IRocketNodeStaking.sol';\n\ncontract OperatorDistributor is UpgradeableBase, Errors {\n event MinipoolCreated(address indexed _minipoolAddress, address indexed _nodeAddress);\n event MinipoolDestroyed(address indexed _minipoolAddress, address indexed _nodeAddress);\n event WarningNoMiniPoolsToHarvest();\n event WarningMinipoolNotStaking(address indexed _minipoolAddress, MinipoolStatus indexed _status);\n\n using Math for uint256;\n\n // The total amount of Ether (ETH) funded or allocated by the contract.\n // This variable keeps track of the ETH resources managed within this contract,\n uint256 public fundedEth;\n\n // The total amount of Rocket Pool tokens (RPL) funded or allocated by the contract.\n // This field is used to track the RPL token balance managed by the contract,\n uint256 public fundedRpl;\n\n address[] public minipoolAddresses;\n\n uint256 public nextMinipoolHavestIndex;\n uint256 public targetStakeRatio;\n\n uint256 public numMinipoolsProcessedPerInterval;\n\n uint256 public requiredLEBStaked;\n\n mapping(address => uint256) public minipoolIndexMap;\n mapping(address => uint256) public minipoolAmountFundedEth;\n mapping(address => uint256) public minipoolAmountFundedRpl;\n\n mapping(address => address[]) public nodeOperatorOwnedMinipools;\n mapping(address => uint256) public nodeOperatorEthStaked;\n\n constructor() initializer {}\n\n /**\n * @notice Initializes the contract with the provided storage address.\n * @dev This function should only be called once, during contract creation or proxy initialization.\n * It overrides the `initialize` function from a parent contract.\n * @param _directory The address of the storage contract.\n */\n function initialize(address _directory) public override initializer {\n super.initialize(_directory);\n targetStakeRatio = 1.5e18; // 150%\n numMinipoolsProcessedPerInterval = 1;\n\n // defaulting these to 8eth to only allow LEB8 minipools\n requiredLEBStaked = 8 ether;\n }\n\n /**\n * @notice Receives incoming Ether and adds it to the queued balance.\n * @dev This is the fallback function that is called when Ether is sent directly to the contract.\n */\n receive() external payable {\n address payable dp = _directory.getDepositPoolAddress();\n console.log('fallback od initial');\n console.log(address(this).balance);\n\n if (msg.sender != dp) {\n (bool success, ) = dp.call{value: msg.value}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n }\n\n console.log('fallback od final');\n console.log(address(this).balance);\n }\n\n function _rebalanceLiquidity() internal nonReentrant {\n address payable dp = _directory.getDepositPoolAddress();\n (bool success, ) = dp.call{value: address(this).balance}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n\n IERC20 rpl = IERC20(_directory.getRPLAddress());\n SafeERC20.safeTransfer(rpl, dp, rpl.balanceOf(address(this)));\n FundRouter(dp).sendRplToDistributors();\n }\n\n /// @notice Gets the total ETH value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function sums up the balance of this contract with the amount of funded ETH across all minipools.\n /// Ensure that all sources of ETH (like the OperatorDistributor) are properly accounted for in the calculation.\n /// @return The total amount of Ether locked inside the protocol.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + fundedEth;\n }\n\n /// @notice Gets the total RPL value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function calculates the total RPL by summing up the balance of RPL tokens of this contract\n /// with the amount of funded RPL across all minipools. It retrieves the RPL token address from the `_directory` contract.\n /// Ensure that all sources of RPL (like the OperatorDistributor) are accurately accounted for.\n /// @return The total amount of RPL tokens locked inside the protocol.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this)) + fundedRpl;\n }\n\n /**\n * @notice Removes a minipool address from the tracked list when a node operator exits.\n * @dev This function efficiently reorders the minipool addresses array and updates the index map.\n * It then resets the funded amount of ETH and RPL tokens for the removed minipool.\n * Should only be called by authorized protocol actors or admin.\n * @param _address The address of the minipool to be removed.\n *\n * Emits a `MinipoolDestroyed` event upon successful removal.\n */ function removeMinipoolAddress(address _address) public onlyProtocolOrAdmin {\n uint index = minipoolIndexMap[_address] - 1;\n require(index < minipoolAddresses.length, 'Address not found.');\n\n // Move the last address into the spot located by index\n address lastAddress = minipoolAddresses[minipoolAddresses.length - 1];\n minipoolAddresses[index] = lastAddress;\n minipoolIndexMap[lastAddress] = index;\n\n // Remove the last address\n minipoolAddresses.pop();\n delete minipoolIndexMap[_address];\n\n // Set amount funded to 0 since it's being returned to DP\n minipoolAmountFundedEth[_address] = 0;\n minipoolAmountFundedRpl[_address] = 0;\n\n emit MinipoolDestroyed(_address, IMinipool(_address).getNodeAddress());\n }\n\n /**\n * @notice Removes a node operator and all associated minipools.\n * @dev Iterates through all minipools owned by the node operator and removes them.\n * This action cannot be reversed, so it should be executed with caution.\n * Only authorized protocol actors or admin can call this function.\n * @param _address The address of the node operator to be removed.\n */\n function removeNodeOperator(address _address) external onlyProtocolOrAdmin {\n // remove all minipools owned by node operator\n address[] memory minipools = nodeOperatorOwnedMinipools[_address];\n for (uint i = 0; i < minipools.length; i++) {\n removeMinipoolAddress(minipools[i]);\n }\n delete nodeOperatorOwnedMinipools[_address];\n }\n\n /**\n * @notice Stakes the minimum required RPL tokens on behalf of a node.\n * @dev This function first fetches the node's minimum RPL stake requirement,\n * approves the Node Staking contract to spend the RPL, and then stakes the RPL for the node.\n * It assumes that the contract already holds enough RPL tokens for the staking process.\n * @param _nodeAddress The address of the node for which RPL should be staked.\n */\n function _stakeRPLFor(address _nodeAddress) internal {\n IRocketNodeStaking nodeStaking = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress());\n uint256 minimumRplStake = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress())\n .getNodeMinimumRPLStake(_nodeAddress);\n\n fundedRpl += minimumRplStake;\n\n // approve the node staking contract to spend the RPL\n RocketTokenRPLInterface rpl = RocketTokenRPLInterface(_directory.getRPLAddress());\n require(rpl.approve(getDirectory().getRocketNodeStakingAddress(), minimumRplStake));\n\n // update amount funded rpl\n minipoolAmountFundedRpl[_nodeAddress] = minimumRplStake;\n\n nodeStaking.stakeRPLFor(_nodeAddress, minimumRplStake);\n }\n\n /**\n * @notice Prepares a node for minipool creation by setting up necessary staking and validations.\n * @dev This function first validates the node's withdrawal address, then calculates the required amount of\n * RPL to stake based on the number of validators associated with the node, and performs a top-up.\n * Only the protocol or admin can call this function.\n * @param _NodeAccount The address of the validator account belonging to the Node Operator\n */\n function provisionLiquiditiesForMinipoolCreation(\n address _nodeOperator,\n address _NodeAccount,\n uint256 _bond\n ) external onlyProtocolOrAdmin {\n _rebalanceLiquidity();\n require(_bond == requiredLEBStaked, 'OperatorDistributor: Bad _bond amount, should be `requiredLEBStaked`');\n fundedEth += _bond;\n nodeOperatorEthStaked[_nodeOperator] += _bond;\n\n // by default this bonds 150% of stake according to max stake defined here: https://docs.rocketpool.net/guides/node/create-validator#staking-rpl\n // performTopUp(_NodeAccount, nodeOperatorEthStaked[_nodeOperator]);\n (bool success, bytes memory data) = _NodeAccount.call{value: _bond}('');\n if (!success) {\n revert LowLevelEthTransfer(success, data);\n }\n }\n\n /**\n * @notice Tops up the node operator's RPL stake if it falls below the target stake ratio.\n * @dev This function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it calculates the necessary RPL amount to\n * bring the stake ratio back to the target. Then, the function either stakes the required RPL or stakes\n * the remaining RPL balance if it's not enough.\n * @param _NodeAccount The address of the node.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n */\n function performTopUp(address _NodeAccount, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(\n _NodeAccount\n );\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n uint256 requiredStakeRpl = minuend < rplStaked ? 0 : minuend - rplStaked;\n // Make sure the contract has enough RPL to stake\n uint256 currentRplBalance = RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n if (currentRplBalance >= requiredStakeRpl) {\n if (requiredStakeRpl == 0) {\n return;\n }\n // stakeRPLOnBehalfOf\n // transfer RPL to deposit pool\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n requiredStakeRpl\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, requiredStakeRpl);\n } else {\n if (currentRplBalance == 0) {\n return;\n }\n // stake what we have\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n currentRplBalance\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, currentRplBalance);\n }\n }\n }\n\n function performTopDown(address _nodeAddress, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(_nodeAddress);\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n uint256 excessRpl = rplStaked > maxRplStake ? rplStaked - maxRplStake : 0;\n\n if (excessRpl > 0) {\n fundedRpl -= excessRpl;\n FundRouter(_directory.getDepositPoolAddress()).unstakeRpl(_nodeAddress, excessRpl);\n\n // Update the amount of RPL funded by the node\n minipoolAmountFundedRpl[_nodeAddress] -= excessRpl;\n }\n }\n }\n\n /**\n * @notice Calculates the amount of RPL needed to top up the node operator's stake to the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it returns the necessary RPL amount to\n * bring the stake ratio back to the target.\n * @param _existingRplStake Prior crap staked\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return requiredStakeRpl The amount of RPL required to top up to the target stake ratio.\n */\n function calculateRequiredRplTopUp(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 requiredStakeRpl) {\n console.log('before calling getPriceFetcherAddress');\n console.logAddress(getDirectory().getPriceFetcherAddress());\n console.log('B');\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n console.log('price', ethPriceInRpl);\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n requiredStakeRpl = minuend < _existingRplStake ? 0 : minuend - _existingRplStake;\n } else {\n requiredStakeRpl = 0;\n }\n return requiredStakeRpl;\n }\n\n /**\n * @notice Calculates the amount of RPL that can be withdrawn from the node operator's stake without falling below the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is above a predefined target, it returns the maximum RPL amount that can be withdrawn\n * while still maintaining at least the target stake ratio.\n * @param _existingRplStake The amount of RPL currently staked by the node operator.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return withdrawableStakeRpl The maximum amount of RPL that can be withdrawn while maintaining the target stake ratio.\n */\n function calculateRequiredRplTopDown(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 withdrawableStakeRpl) {\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n withdrawableStakeRpl = _existingRplStake > maxRplStake ? _existingRplStake - maxRplStake : 0;\n } else {\n withdrawableStakeRpl = 0;\n }\n return withdrawableStakeRpl;\n }\n\n /**\n * @notice Processes rewards for a predefined number of minipools. This function is meant to be called during\n * the creation of new intervals. It serves to withdraw rewards from minipools and to top up the RPL stake.\n * @dev The function first checks if there are any minipools to process. If there aren't, it emits a warning event\n * and exits. Otherwise, it calls the internal function _processNextMinipool() for a certain number of times defined\n * by numMinipoolsProcessedPerInterval.\n */\n function processNextMinipool() external onlyProtocol {\n if (minipoolAddresses.length == 0) {\n emit WarningNoMiniPoolsToHarvest();\n return;\n }\n\n for (uint i = 0; i < numMinipoolsProcessedPerInterval; i++) {\n _processNextMinipool();\n }\n }\n\n function OnMinipoolCreated(address newMinipoolAddress, address nodeAddress, uint256 bond) external {\n if (!_directory.hasRole(Constants.CORE_PROTOCOL_ROLE, msg.sender)) {\n revert BadRole(Constants.CORE_PROTOCOL_ROLE, msg.sender);\n }\n\n // register minipool with node operator\n Whitelist whitelist = Whitelist(getDirectory().getWhitelistAddress());\n whitelist.registerNewValidator(nodeAddress);\n\n // new minipool owned by node operator\n nodeOperatorOwnedMinipools[nodeAddress].push(newMinipoolAddress);\n\n // add minipool to minipoolAddresses\n minipoolAddresses.push(newMinipoolAddress);\n minipoolIndexMap[newMinipoolAddress] = minipoolAddresses.length;\n\n emit MinipoolCreated(newMinipoolAddress, nodeAddress);\n\n // updated amount funded eth\n minipoolAmountFundedEth[newMinipoolAddress] = bond;\n }\n\n /**\n * @dev Processes a single minipool by performing RPL top-up and distributing balance if certain conditions are met.\n */\n function _processNextMinipool() internal {\n uint256 index = nextMinipoolHavestIndex % minipoolAddresses.length;\n IMinipool minipool = IMinipool(minipoolAddresses[index]);\n\n if (minipool.getStatus() != MinipoolStatus.Staking) {\n emit WarningMinipoolNotStaking(address(minipool), minipool.getStatus());\n return;\n }\n\n // process top up\n address nodeAddress = minipool.getNodeAddress();\n\n uint256 ethStaked = nodeOperatorEthStaked[nodeAddress];\n\n performTopUp(nodeAddress, ethStaked);\n performTopDown(nodeAddress, ethStaked);\n\n nextMinipoolHavestIndex = index + 1;\n\n uint256 balance = minipool.getNodeDepositBalance();\n minipool.distributeBalance(balance >= 8 ether);\n }\n\n /**\n * @notice Set the number of minipools to be processed per interval.\n * @dev This function can only be called by the contract's admin.\n * Adjusting this parameter allows the admin to control and optimize the load\n * on the network for each interval, especially in scenarios with a large number of minipools.\n * @param _numMinipoolsProcessedPerInterval The new number of minipools to process per interval.\n */\n function setNumMinipoolsProcessedPerInterval(uint256 _numMinipoolsProcessedPerInterval) external onlyAdmin {\n numMinipoolsProcessedPerInterval = _numMinipoolsProcessedPerInterval;\n }\n\n function setBondRequirments(uint256 _requiredLEBStaked) external onlyAdmin {\n requiredLEBStaked = _requiredLEBStaked;\n }\n\n function onNodeMinipoolDestroy(address _nodeOperator, uint256 _bond) external onlyProtocol {\n fundedEth -= _bond;\n nodeOperatorEthStaked[_nodeOperator] -= _bond;\n }\n\n /**\n * @notice Retrieves the list of minipool addresses managed by the contract.\n * @dev This function provides a way to fetch all the current minipool addresses in memory.\n * Useful for off-chain services or frontend interfaces that need to display or interact\n * with the various minipools.\n * @return A list of addresses corresponding to the minipools.\n */\n function getMinipoolAddresses() external view returns (address[] memory) {\n return minipoolAddresses;\n }\n\n function transferWEthToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getWETHVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n address weth = _directory.getWETHAddress();\n\n // Check if there's enough WETH in the contract\n uint256 wethBalance = IWETH(weth).balanceOf(address(this));\n if (wethBalance >= _amount) {\n IWETH(weth).deposit{value: _amount}();\n SafeERC20.safeTransfer(IERC20(weth), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n\n function transferRplToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getRPLVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n\n // Check if there's enough RPL in the contract\n address rpl = IERC4626Upgradeable(vault).asset();\n uint256 rplBalance = IERC20(rpl).balanceOf(address(this));\n if (rplBalance >= _amount) {\n SafeERC20.safeTransfer(IERC20(rpl), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n}\n","line":76,"range":[2919,2953]},"functionType":3},{"type":23,"sourceReference":{"function":"log","contract":"OperatorDistributor","sourceName":"hardhat/console.sol","sourceContent":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n\n}\n","line":197,"range":[6141,6183]}}],"data":"0x"}, code=UNPREDICTABLE_GAS_LIMIT, version=providers/5.7.2) at Logger.makeError (node_modules/@ethersproject/logger/src.ts/index.ts:269:28) at Logger.throwError (node_modules/@ethersproject/logger/src.ts/index.ts:281:20) at checkError (node_modules/@ethersproject/providers/src.ts/json-rpc-provider.ts:78:20) @@ -370,7 +370,7 @@ price 51127333500000000000 2) Validator Account Factory fails - not whitelisted: - Error: cannot estimate gas; transaction may fail or may require manual gas limit [ See: https://links.ethers.org/v5-errors-UNPREDICTABLE_GAS_LIMIT ] (reason="Transaction reverted: contract call run out of gas and made the transaction revert", method="estimateGas", transaction={"from":"0x1CBd3b2770909D4e10f157cABC84C7264073C9Ec","to":"0x10e38eE9dd4C549b61400Fc19347D00eD3edAfC4","value":{"type":"BigNumber","hex":"0x6f05b59d3b200000"},"accessList":null}, error={"stackTrace":[{"type":2,"address":{"type":"Buffer","data":[16,227,142,233,221,76,84,155,97,64,15,193,147,71,208,14,211,237,175,196]}},{"type":0,"sourceReference":{"function":"","contract":"OperatorDistributor","sourceName":"contracts/Operator/OperatorDistributor.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';\n\nimport '../UpgradeableBase.sol';\nimport '../Whitelist/Whitelist.sol';\nimport '../FundRouter.sol';\nimport '../PriceFetcher.sol';\nimport '../Tokens/WETHVault.sol';\n\nimport '../Utils/Constants.sol';\nimport '../Utils/Errors.sol';\n\nimport '../Interfaces/IWETH.sol';\nimport '../Interfaces/RocketPool/IRocketStorage.sol';\nimport '../Interfaces/RocketPool/IMinipool.sol';\nimport '../Interfaces/RocketPool/IRocketNodeManager.sol';\nimport '../Interfaces/RocketPool/IRocketNodeStaking.sol';\n\ncontract OperatorDistributor is UpgradeableBase, Errors {\n event MinipoolCreated(address indexed _minipoolAddress, address indexed _nodeAddress);\n event MinipoolDestroyed(address indexed _minipoolAddress, address indexed _nodeAddress);\n event WarningNoMiniPoolsToHarvest();\n event WarningMinipoolNotStaking(address indexed _minipoolAddress, MinipoolStatus indexed _status);\n\n using Math for uint256;\n\n // The total amount of Ether (ETH) funded or allocated by the contract.\n // This variable keeps track of the ETH resources managed within this contract,\n uint256 public fundedEth;\n\n // The total amount of Rocket Pool tokens (RPL) funded or allocated by the contract.\n // This field is used to track the RPL token balance managed by the contract,\n uint256 public fundedRpl;\n\n address[] public minipoolAddresses;\n\n uint256 public nextMinipoolHavestIndex;\n uint256 public targetStakeRatio;\n\n uint256 public numMinipoolsProcessedPerInterval;\n\n uint256 public requiredLEBStaked;\n\n mapping(address => uint256) public minipoolIndexMap;\n mapping(address => uint256) public minipoolAmountFundedEth;\n mapping(address => uint256) public minipoolAmountFundedRpl;\n\n mapping(address => address[]) public nodeOperatorOwnedMinipools;\n mapping(address => uint256) public nodeOperatorEthStaked;\n\n constructor() initializer {}\n\n /**\n * @notice Initializes the contract with the provided storage address.\n * @dev This function should only be called once, during contract creation or proxy initialization.\n * It overrides the `initialize` function from a parent contract.\n * @param _directory The address of the storage contract.\n */\n function initialize(address _directory) public override initializer {\n super.initialize(_directory);\n targetStakeRatio = 1.5e18; // 150%\n numMinipoolsProcessedPerInterval = 1;\n\n // defaulting these to 8eth to only allow LEB8 minipools\n requiredLEBStaked = 8 ether;\n }\n\n /**\n * @notice Receives incoming Ether and adds it to the queued balance.\n * @dev This is the fallback function that is called when Ether is sent directly to the contract.\n */\n receive() external payable {\n address payable dp = _directory.getDepositPoolAddress();\n console.log('fallback od initial');\n console.log(address(this).balance);\n\n if (msg.sender != dp) {\n (bool success, ) = dp.call{value: msg.value}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n }\n\n console.log('fallback od final');\n console.log(address(this).balance);\n }\n\n function _rebalanceLiquidity() internal nonReentrant {\n address payable dp = _directory.getDepositPoolAddress();\n (bool success, ) = dp.call{value: address(this).balance}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n\n IERC20 rpl = IERC20(_directory.getRPLAddress());\n SafeERC20.safeTransfer(rpl, dp, rpl.balanceOf(address(this)));\n FundRouter(dp).sendRplToDistributors();\n }\n\n /// @notice Gets the total ETH value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function sums up the balance of this contract with the amount of funded ETH across all minipools.\n /// Ensure that all sources of ETH (like the OperatorDistributor) are properly accounted for in the calculation.\n /// @return The total amount of Ether locked inside the protocol.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + fundedEth;\n }\n\n /// @notice Gets the total RPL value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function calculates the total RPL by summing up the balance of RPL tokens of this contract\n /// with the amount of funded RPL across all minipools. It retrieves the RPL token address from the `_directory` contract.\n /// Ensure that all sources of RPL (like the OperatorDistributor) are accurately accounted for.\n /// @return The total amount of RPL tokens locked inside the protocol.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this)) + fundedRpl;\n }\n\n /**\n * @notice Removes a minipool address from the tracked list when a node operator exits.\n * @dev This function efficiently reorders the minipool addresses array and updates the index map.\n * It then resets the funded amount of ETH and RPL tokens for the removed minipool.\n * Should only be called by authorized protocol actors or admin.\n * @param _address The address of the minipool to be removed.\n *\n * Emits a `MinipoolDestroyed` event upon successful removal.\n */ function removeMinipoolAddress(address _address) public onlyProtocolOrAdmin {\n uint index = minipoolIndexMap[_address] - 1;\n require(index < minipoolAddresses.length, 'Address not found.');\n\n // Move the last address into the spot located by index\n address lastAddress = minipoolAddresses[minipoolAddresses.length - 1];\n minipoolAddresses[index] = lastAddress;\n minipoolIndexMap[lastAddress] = index;\n\n // Remove the last address\n minipoolAddresses.pop();\n delete minipoolIndexMap[_address];\n\n // Set amount funded to 0 since it's being returned to DP\n minipoolAmountFundedEth[_address] = 0;\n minipoolAmountFundedRpl[_address] = 0;\n\n emit MinipoolDestroyed(_address, IMinipool(_address).getNodeAddress());\n }\n\n /**\n * @notice Removes a node operator and all associated minipools.\n * @dev Iterates through all minipools owned by the node operator and removes them.\n * This action cannot be reversed, so it should be executed with caution.\n * Only authorized protocol actors or admin can call this function.\n * @param _address The address of the node operator to be removed.\n */\n function removeNodeOperator(address _address) external onlyProtocolOrAdmin {\n // remove all minipools owned by node operator\n address[] memory minipools = nodeOperatorOwnedMinipools[_address];\n for (uint i = 0; i < minipools.length; i++) {\n removeMinipoolAddress(minipools[i]);\n }\n delete nodeOperatorOwnedMinipools[_address];\n }\n\n /**\n * @notice Stakes the minimum required RPL tokens on behalf of a node.\n * @dev This function first fetches the node's minimum RPL stake requirement,\n * approves the Node Staking contract to spend the RPL, and then stakes the RPL for the node.\n * It assumes that the contract already holds enough RPL tokens for the staking process.\n * @param _nodeAddress The address of the node for which RPL should be staked.\n */\n function _stakeRPLFor(address _nodeAddress) internal {\n IRocketNodeStaking nodeStaking = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress());\n uint256 minimumRplStake = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress())\n .getNodeMinimumRPLStake(_nodeAddress);\n\n fundedRpl += minimumRplStake;\n\n // approve the node staking contract to spend the RPL\n RocketTokenRPLInterface rpl = RocketTokenRPLInterface(_directory.getRPLAddress());\n require(rpl.approve(getDirectory().getRocketNodeStakingAddress(), minimumRplStake));\n\n // update amount funded rpl\n minipoolAmountFundedRpl[_nodeAddress] = minimumRplStake;\n\n nodeStaking.stakeRPLFor(_nodeAddress, minimumRplStake);\n }\n\n /**\n * @notice Prepares a node for minipool creation by setting up necessary staking and validations.\n * @dev This function first validates the node's withdrawal address, then calculates the required amount of\n * RPL to stake based on the number of validators associated with the node, and performs a top-up.\n * Only the protocol or admin can call this function.\n * @param _NodeAccount The address of the validator account belonging to the Node Operator\n */\n function provisionLiquiditiesForMinipoolCreation(\n address _nodeOperator,\n address _NodeAccount,\n uint256 _bond\n ) external onlyProtocolOrAdmin {\n _rebalanceLiquidity();\n require(_bond == requiredLEBStaked, 'OperatorDistributor: Bad _bond amount, should be `requiredLEBStaked`');\n fundedEth += _bond;\n nodeOperatorEthStaked[_nodeOperator] += _bond;\n\n // by default this bonds 150% of stake according to max stake defined here: https://docs.rocketpool.net/guides/node/create-validator#staking-rpl\n // performTopUp(_NodeAccount, nodeOperatorEthStaked[_nodeOperator]);\n (bool success, bytes memory data) = _NodeAccount.call{value: _bond}('');\n if (!success) {\n revert LowLevelEthTransfer(success, data);\n }\n }\n\n /**\n * @notice Tops up the node operator's RPL stake if it falls below the target stake ratio.\n * @dev This function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it calculates the necessary RPL amount to\n * bring the stake ratio back to the target. Then, the function either stakes the required RPL or stakes\n * the remaining RPL balance if it's not enough.\n * @param _NodeAccount The address of the node.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n */\n function performTopUp(address _NodeAccount, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(\n _NodeAccount\n );\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n uint256 requiredStakeRpl = minuend < rplStaked ? 0 : minuend - rplStaked;\n // Make sure the contract has enough RPL to stake\n uint256 currentRplBalance = RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n if (currentRplBalance >= requiredStakeRpl) {\n if (requiredStakeRpl == 0) {\n return;\n }\n // stakeRPLOnBehalfOf\n // transfer RPL to deposit pool\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n requiredStakeRpl\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, requiredStakeRpl);\n } else {\n if (currentRplBalance == 0) {\n return;\n }\n // stake what we have\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n currentRplBalance\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, currentRplBalance);\n }\n }\n }\n\n function performTopDown(address _nodeAddress, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(_nodeAddress);\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n uint256 excessRpl = rplStaked > maxRplStake ? rplStaked - maxRplStake : 0;\n\n if (excessRpl > 0) {\n fundedRpl -= excessRpl;\n FundRouter(_directory.getDepositPoolAddress()).unstakeRpl(_nodeAddress, excessRpl);\n\n // Update the amount of RPL funded by the node\n minipoolAmountFundedRpl[_nodeAddress] -= excessRpl;\n }\n }\n }\n\n /**\n * @notice Calculates the amount of RPL needed to top up the node operator's stake to the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it returns the necessary RPL amount to\n * bring the stake ratio back to the target.\n * @param _existingRplStake Prior crap staked\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return requiredStakeRpl The amount of RPL required to top up to the target stake ratio.\n */\n function calculateRequiredRplTopUp(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 requiredStakeRpl) {\n console.log('before calling getPriceFetcherAddress');\n console.logAddress(getDirectory().getPriceFetcherAddress());\n console.log('B');\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n console.log('price', ethPriceInRpl);\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n requiredStakeRpl = minuend < _existingRplStake ? 0 : minuend - _existingRplStake;\n } else {\n requiredStakeRpl = 0;\n }\n return requiredStakeRpl;\n }\n\n /**\n * @notice Calculates the amount of RPL that can be withdrawn from the node operator's stake without falling below the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is above a predefined target, it returns the maximum RPL amount that can be withdrawn\n * while still maintaining at least the target stake ratio.\n * @param _existingRplStake The amount of RPL currently staked by the node operator.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return withdrawableStakeRpl The maximum amount of RPL that can be withdrawn while maintaining the target stake ratio.\n */\n function calculateRequiredRplTopDown(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 withdrawableStakeRpl) {\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n withdrawableStakeRpl = _existingRplStake > maxRplStake ? _existingRplStake - maxRplStake : 0;\n } else {\n withdrawableStakeRpl = 0;\n }\n return withdrawableStakeRpl;\n }\n\n /**\n * @notice Processes rewards for a predefined number of minipools. This function is meant to be called during\n * the creation of new intervals. It serves to withdraw rewards from minipools and to top up the RPL stake.\n * @dev The function first checks if there are any minipools to process. If there aren't, it emits a warning event\n * and exits. Otherwise, it calls the internal function _processNextMinipool() for a certain number of times defined\n * by numMinipoolsProcessedPerInterval.\n */\n function processNextMinipool() external onlyProtocol {\n if (minipoolAddresses.length == 0) {\n emit WarningNoMiniPoolsToHarvest();\n return;\n }\n\n for (uint i = 0; i < numMinipoolsProcessedPerInterval; i++) {\n _processNextMinipool();\n }\n }\n\n function OnMinipoolCreated(address newMinipoolAddress, address nodeAddress, uint256 bond) external {\n if (!_directory.hasRole(Constants.CORE_PROTOCOL_ROLE, msg.sender)) {\n revert BadRole(Constants.CORE_PROTOCOL_ROLE, msg.sender);\n }\n\n // register minipool with node operator\n Whitelist whitelist = Whitelist(getDirectory().getWhitelistAddress());\n whitelist.registerNewValidator(nodeAddress);\n\n // new minipool owned by node operator\n nodeOperatorOwnedMinipools[nodeAddress].push(newMinipoolAddress);\n\n // add minipool to minipoolAddresses\n minipoolAddresses.push(newMinipoolAddress);\n minipoolIndexMap[newMinipoolAddress] = minipoolAddresses.length;\n\n emit MinipoolCreated(newMinipoolAddress, nodeAddress);\n\n // updated amount funded eth\n minipoolAmountFundedEth[newMinipoolAddress] = bond;\n }\n\n /**\n * @dev Processes a single minipool by performing RPL top-up and distributing balance if certain conditions are met.\n */\n function _processNextMinipool() internal {\n uint256 index = nextMinipoolHavestIndex % minipoolAddresses.length;\n IMinipool minipool = IMinipool(minipoolAddresses[index]);\n\n if (minipool.getStatus() != MinipoolStatus.Staking) {\n emit WarningMinipoolNotStaking(address(minipool), minipool.getStatus());\n return;\n }\n\n // process top up\n address nodeAddress = minipool.getNodeAddress();\n\n uint256 ethStaked = nodeOperatorEthStaked[nodeAddress];\n\n performTopUp(nodeAddress, ethStaked);\n performTopDown(nodeAddress, ethStaked);\n\n nextMinipoolHavestIndex = index + 1;\n\n uint256 balance = minipool.getNodeDepositBalance();\n minipool.distributeBalance(balance >= 8 ether);\n }\n\n /**\n * @notice Set the number of minipools to be processed per interval.\n * @dev This function can only be called by the contract's admin.\n * Adjusting this parameter allows the admin to control and optimize the load\n * on the network for each interval, especially in scenarios with a large number of minipools.\n * @param _numMinipoolsProcessedPerInterval The new number of minipools to process per interval.\n */\n function setNumMinipoolsProcessedPerInterval(uint256 _numMinipoolsProcessedPerInterval) external onlyAdmin {\n numMinipoolsProcessedPerInterval = _numMinipoolsProcessedPerInterval;\n }\n\n function setBondRequirments(uint256 _requiredLEBStaked) external onlyAdmin {\n requiredLEBStaked = _requiredLEBStaked;\n }\n\n function onNodeOperatorDissolved(address _nodeOperator, uint256 _bond) external onlyProtocol {\n fundedEth -= _bond;\n nodeOperatorEthStaked[_nodeOperator] -= _bond;\n }\n\n /**\n * @notice Retrieves the list of minipool addresses managed by the contract.\n * @dev This function provides a way to fetch all the current minipool addresses in memory.\n * Useful for off-chain services or frontend interfaces that need to display or interact\n * with the various minipools.\n * @return A list of addresses corresponding to the minipools.\n */\n function getMinipoolAddresses() external view returns (address[] memory) {\n return minipoolAddresses;\n }\n\n function transferWEthToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getWETHVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n address weth = _directory.getWETHAddress();\n\n // Check if there's enough WETH in the contract\n uint256 wethBalance = IWETH(weth).balanceOf(address(this));\n if (wethBalance >= _amount) {\n IWETH(weth).deposit{value: _amount}();\n SafeERC20.safeTransfer(IERC20(weth), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n\n function transferRplToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getRPLVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n\n // Check if there's enough RPL in the contract\n address rpl = IERC4626Upgradeable(vault).asset();\n uint256 rplBalance = IERC20(rpl).balanceOf(address(this));\n if (rplBalance >= _amount) {\n SafeERC20.safeTransfer(IERC20(rpl), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n}\n","line":82,"range":[3167,3206]},"functionType":3},{"type":2,"address":{"type":"Buffer","data":[38,46,43,80,33,150,32,34,108,95,181,149,100,50,168,143,255,217,75,167]}},{"type":0,"sourceReference":{"function":"sendEthToDistributors","contract":"FundRouter","sourceName":"contracts/FundRouter.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/Strings.sol';\n\nimport './UpgradeableBase.sol';\nimport './Operator/OperatorDistributor.sol';\nimport './Operator/YieldDistributor.sol';\nimport './Interfaces/RocketPool/IRocketNodeStaking.sol';\nimport './Tokens/WETHVault.sol';\nimport './Tokens/RPLVault.sol';\n\nimport './Interfaces/IWETH.sol';\nimport './Utils/Constants.sol';\n\n/// @custom:security-contact info@nodeoperator.org\n/// @notice Immutable deposit pool which holds deposits and provides a minimum source of liquidity for depositors.\n/// ETH + RPL intakes from token mints and validator yields and sends to respective ERC4246 vaults.\ncontract FundRouter is UpgradeableBase {\n constructor() initializer {}\n\n /// @dev Initializes the FundRouter contract with the specified directory address.\n /// @param directoryAddress The address of the directory contract.\n function initialize(address directoryAddress) public virtual override initializer {\n super.initialize(directoryAddress);\n }\n\n ///--------\n /// GETTERS\n ///--------\n\n /// @notice Retrieves the total ETH and WETH value locked inside this deposit pool.\n /// @dev This function calculates and returns the combined value of ETH and WETH held by the deposit pool.\n /// It sums the ETH balance of this contract and the WETH balance from the WETH contract.\n /// @return The total value in ETH and WETH locked in the deposit pool.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + IWETH(_directory.getWETHAddress()).balanceOf(address(this));\n }\n\n /// @notice Retrieves the total RPL value locked inside this deposit pool.\n /// @dev This function calculates and returns the total amount of RPL tokens held by the deposit pool.\n /// @return The total value in RPL locked in the deposit pool.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n }\n\n ///--------\n /// ACTIONS\n ///--------\n\n /// @notice Unstakes a specified amount of RPL tokens.\n /// @dev This function allows an administrator to unstake a specified amount of RPL tokens from the Rocket Node Staking contract.\n /// @param _excessRpl The amount of RPL tokens to unstake.\n /// @dev The tokens will be withdrawn from the Rocket Node Staking contract.\n function unstakeRpl(address _nodeAddress, uint256 _excessRpl) external onlyAdmin {\n IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress()).withdrawRPL(_nodeAddress, _excessRpl);\n }\n\n /// @notice Stakes a specified amount of RPL tokens on behalf of a node operator.\n /// @dev This function allows the protocol or an administrator to stake a specified amount of RPL tokens on behalf of a node operator\n /// using the Rocket Node Staking contract.\n /// @param _nodeAddress The address of the node operator on whose behalf the RPL tokens are being staked.\n /// @param _amount The amount of RPL tokens to stake.\n /// @dev This function ensures that the specified amount of RPL tokens is approved and then staked for the given node operator.\n function stakeRPLFor(address _nodeAddress, uint256 _amount) external onlyProtocolOrAdmin {\n SafeERC20.safeApprove(\n RocketTokenRPLInterface(_directory.getRPLAddress()),\n _directory.getRocketNodeStakingAddress(),\n 0\n );\n SafeERC20.safeApprove(\n RocketTokenRPLInterface(_directory.getRPLAddress()),\n _directory.getRocketNodeStakingAddress(),\n _amount\n );\n IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).stakeRPLFor(_nodeAddress, _amount);\n }\n\n function sendEthToDistributors() public {\n console.log('sendEthToDistributors.A');\n // Convert entire WETH balance of this contract to ETH\n IWETH WETH = IWETH(_directory.getWETHAddress());\n uint256 wethBalance = WETH.balanceOf(address(this));\n WETH.withdraw(wethBalance);\n console.log('sendEthToDistributors.B');\n\n // Initialize the vault and operator distributor addresses\n WETHVault vweth = WETHVault(getDirectory().getWETHVaultAddress());\n address payable operatorDistributor = payable(getDirectory().getOperatorDistributorAddress());\n console.log('sendEthToDistributors.C');\n\n // Calculate required capital and total balance\n uint256 requiredCapital = vweth.getRequiredCollateral();\n uint256 ethBalance = address(this).balance;\n console.log('sendEthToDistributors.D');\n\n if (ethBalance >= requiredCapital) {\n console.log('sendEthToDistributors.E');\n\n // Send required capital in WETH to vault and surplus ETH to operator distributor\n WETH.deposit{value: requiredCapital}();\n console.log('sendEthToDistributors.E1');\n\n SafeERC20.safeTransfer(WETH, address(vweth), requiredCapital);\n console.log('sendEthToDistributors.E2');\n\n uint256 surplus = ethBalance - requiredCapital;\n console.log('sendEthToDistributors.E3');\n\n operatorDistributor.transfer(surplus);\n console.log('sendEthToDistributors.F');\n } else {\n console.log('sendEthToDistributors.G');\n\n // If not enough ETH balance, convert the shortfall in WETH back to ETH and send it\n uint256 shortfall = requiredCapital - ethBalance;\n WETH.deposit{value: shortfall}();\n SafeERC20.safeTransfer(IERC20(address(WETH)), address(vweth), requiredCapital);\n console.log('sendEthToDistributors.H');\n }\n console.log('sendEthToDistributors.I');\n }\n\n function sendRplToDistributors() public {\n console.log('sendRplToDistributors.A');\n\n // Initialize the RPLVault and the Operator Distributor addresses\n RPLVault vrpl = RPLVault(getDirectory().getRPLVaultAddress());\n address operatorDistributor = getDirectory().getOperatorDistributorAddress();\n RocketTokenRPLInterface RPL = RocketTokenRPLInterface(_directory.getRPLAddress());\n console.log('sendRplToDistributors.B');\n\n // Fetch the required capital in RPL and the total RPL balance of the contract\n uint256 requiredCapital = vrpl.getRequiredCollateral();\n uint256 totalBalance = RPL.balanceOf(address(this));\n console.log('sendRplToDistributors.C');\n\n // Determine the amount to send to the RPLVault\n uint256 toRplVault = (totalBalance >= requiredCapital) ? requiredCapital : totalBalance;\n console.log('sendRplToDistributors.D');\n\n // Transfer RPL to the RPLVault\n if (toRplVault > 0) {\n console.log('sendRplToDistributors.E');\n\n SafeERC20.safeTransfer(IERC20(address(RPL)), address(vrpl), toRplVault);\n }\n\n // Transfer any surplus RPL to the Operator Distributor\n if (totalBalance > toRplVault) {\n console.log('sendRplToDistributors.F');\n\n SafeERC20.safeTransfer(IERC20(address(RPL)), operatorDistributor, totalBalance - toRplVault);\n }\n console.log('sendRplToDistributors.G');\n }\n\n /// @notice Receive hook for ETH deposits.\n /// @dev This function allows the contract to receive ETH deposits sent to its address.\n /// It is used as a fallback function to accept incoming ETH transfers.\n receive() external payable {}\n}\n","line":110,"range":[5213,5250]},"functionType":1},{"type":2,"address":{"type":"Buffer","data":[16,227,142,233,221,76,84,155,97,64,15,193,147,71,208,14,211,237,175,196]}},{"type":0,"sourceReference":{"function":"","contract":"OperatorDistributor","sourceName":"contracts/Operator/OperatorDistributor.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';\n\nimport '../UpgradeableBase.sol';\nimport '../Whitelist/Whitelist.sol';\nimport '../FundRouter.sol';\nimport '../PriceFetcher.sol';\nimport '../Tokens/WETHVault.sol';\n\nimport '../Utils/Constants.sol';\nimport '../Utils/Errors.sol';\n\nimport '../Interfaces/IWETH.sol';\nimport '../Interfaces/RocketPool/IRocketStorage.sol';\nimport '../Interfaces/RocketPool/IMinipool.sol';\nimport '../Interfaces/RocketPool/IRocketNodeManager.sol';\nimport '../Interfaces/RocketPool/IRocketNodeStaking.sol';\n\ncontract OperatorDistributor is UpgradeableBase, Errors {\n event MinipoolCreated(address indexed _minipoolAddress, address indexed _nodeAddress);\n event MinipoolDestroyed(address indexed _minipoolAddress, address indexed _nodeAddress);\n event WarningNoMiniPoolsToHarvest();\n event WarningMinipoolNotStaking(address indexed _minipoolAddress, MinipoolStatus indexed _status);\n\n using Math for uint256;\n\n // The total amount of Ether (ETH) funded or allocated by the contract.\n // This variable keeps track of the ETH resources managed within this contract,\n uint256 public fundedEth;\n\n // The total amount of Rocket Pool tokens (RPL) funded or allocated by the contract.\n // This field is used to track the RPL token balance managed by the contract,\n uint256 public fundedRpl;\n\n address[] public minipoolAddresses;\n\n uint256 public nextMinipoolHavestIndex;\n uint256 public targetStakeRatio;\n\n uint256 public numMinipoolsProcessedPerInterval;\n\n uint256 public requiredLEBStaked;\n\n mapping(address => uint256) public minipoolIndexMap;\n mapping(address => uint256) public minipoolAmountFundedEth;\n mapping(address => uint256) public minipoolAmountFundedRpl;\n\n mapping(address => address[]) public nodeOperatorOwnedMinipools;\n mapping(address => uint256) public nodeOperatorEthStaked;\n\n constructor() initializer {}\n\n /**\n * @notice Initializes the contract with the provided storage address.\n * @dev This function should only be called once, during contract creation or proxy initialization.\n * It overrides the `initialize` function from a parent contract.\n * @param _directory The address of the storage contract.\n */\n function initialize(address _directory) public override initializer {\n super.initialize(_directory);\n targetStakeRatio = 1.5e18; // 150%\n numMinipoolsProcessedPerInterval = 1;\n\n // defaulting these to 8eth to only allow LEB8 minipools\n requiredLEBStaked = 8 ether;\n }\n\n /**\n * @notice Receives incoming Ether and adds it to the queued balance.\n * @dev This is the fallback function that is called when Ether is sent directly to the contract.\n */\n receive() external payable {\n address payable dp = _directory.getDepositPoolAddress();\n console.log('fallback od initial');\n console.log(address(this).balance);\n\n if (msg.sender != dp) {\n (bool success, ) = dp.call{value: msg.value}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n }\n\n console.log('fallback od final');\n console.log(address(this).balance);\n }\n\n function _rebalanceLiquidity() internal nonReentrant {\n address payable dp = _directory.getDepositPoolAddress();\n (bool success, ) = dp.call{value: address(this).balance}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n\n IERC20 rpl = IERC20(_directory.getRPLAddress());\n SafeERC20.safeTransfer(rpl, dp, rpl.balanceOf(address(this)));\n FundRouter(dp).sendRplToDistributors();\n }\n\n /// @notice Gets the total ETH value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function sums up the balance of this contract with the amount of funded ETH across all minipools.\n /// Ensure that all sources of ETH (like the OperatorDistributor) are properly accounted for in the calculation.\n /// @return The total amount of Ether locked inside the protocol.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + fundedEth;\n }\n\n /// @notice Gets the total RPL value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function calculates the total RPL by summing up the balance of RPL tokens of this contract\n /// with the amount of funded RPL across all minipools. It retrieves the RPL token address from the `_directory` contract.\n /// Ensure that all sources of RPL (like the OperatorDistributor) are accurately accounted for.\n /// @return The total amount of RPL tokens locked inside the protocol.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this)) + fundedRpl;\n }\n\n /**\n * @notice Removes a minipool address from the tracked list when a node operator exits.\n * @dev This function efficiently reorders the minipool addresses array and updates the index map.\n * It then resets the funded amount of ETH and RPL tokens for the removed minipool.\n * Should only be called by authorized protocol actors or admin.\n * @param _address The address of the minipool to be removed.\n *\n * Emits a `MinipoolDestroyed` event upon successful removal.\n */ function removeMinipoolAddress(address _address) public onlyProtocolOrAdmin {\n uint index = minipoolIndexMap[_address] - 1;\n require(index < minipoolAddresses.length, 'Address not found.');\n\n // Move the last address into the spot located by index\n address lastAddress = minipoolAddresses[minipoolAddresses.length - 1];\n minipoolAddresses[index] = lastAddress;\n minipoolIndexMap[lastAddress] = index;\n\n // Remove the last address\n minipoolAddresses.pop();\n delete minipoolIndexMap[_address];\n\n // Set amount funded to 0 since it's being returned to DP\n minipoolAmountFundedEth[_address] = 0;\n minipoolAmountFundedRpl[_address] = 0;\n\n emit MinipoolDestroyed(_address, IMinipool(_address).getNodeAddress());\n }\n\n /**\n * @notice Removes a node operator and all associated minipools.\n * @dev Iterates through all minipools owned by the node operator and removes them.\n * This action cannot be reversed, so it should be executed with caution.\n * Only authorized protocol actors or admin can call this function.\n * @param _address The address of the node operator to be removed.\n */\n function removeNodeOperator(address _address) external onlyProtocolOrAdmin {\n // remove all minipools owned by node operator\n address[] memory minipools = nodeOperatorOwnedMinipools[_address];\n for (uint i = 0; i < minipools.length; i++) {\n removeMinipoolAddress(minipools[i]);\n }\n delete nodeOperatorOwnedMinipools[_address];\n }\n\n /**\n * @notice Stakes the minimum required RPL tokens on behalf of a node.\n * @dev This function first fetches the node's minimum RPL stake requirement,\n * approves the Node Staking contract to spend the RPL, and then stakes the RPL for the node.\n * It assumes that the contract already holds enough RPL tokens for the staking process.\n * @param _nodeAddress The address of the node for which RPL should be staked.\n */\n function _stakeRPLFor(address _nodeAddress) internal {\n IRocketNodeStaking nodeStaking = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress());\n uint256 minimumRplStake = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress())\n .getNodeMinimumRPLStake(_nodeAddress);\n\n fundedRpl += minimumRplStake;\n\n // approve the node staking contract to spend the RPL\n RocketTokenRPLInterface rpl = RocketTokenRPLInterface(_directory.getRPLAddress());\n require(rpl.approve(getDirectory().getRocketNodeStakingAddress(), minimumRplStake));\n\n // update amount funded rpl\n minipoolAmountFundedRpl[_nodeAddress] = minimumRplStake;\n\n nodeStaking.stakeRPLFor(_nodeAddress, minimumRplStake);\n }\n\n /**\n * @notice Prepares a node for minipool creation by setting up necessary staking and validations.\n * @dev This function first validates the node's withdrawal address, then calculates the required amount of\n * RPL to stake based on the number of validators associated with the node, and performs a top-up.\n * Only the protocol or admin can call this function.\n * @param _NodeAccount The address of the validator account belonging to the Node Operator\n */\n function provisionLiquiditiesForMinipoolCreation(\n address _nodeOperator,\n address _NodeAccount,\n uint256 _bond\n ) external onlyProtocolOrAdmin {\n _rebalanceLiquidity();\n require(_bond == requiredLEBStaked, 'OperatorDistributor: Bad _bond amount, should be `requiredLEBStaked`');\n fundedEth += _bond;\n nodeOperatorEthStaked[_nodeOperator] += _bond;\n\n // by default this bonds 150% of stake according to max stake defined here: https://docs.rocketpool.net/guides/node/create-validator#staking-rpl\n // performTopUp(_NodeAccount, nodeOperatorEthStaked[_nodeOperator]);\n (bool success, bytes memory data) = _NodeAccount.call{value: _bond}('');\n if (!success) {\n revert LowLevelEthTransfer(success, data);\n }\n }\n\n /**\n * @notice Tops up the node operator's RPL stake if it falls below the target stake ratio.\n * @dev This function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it calculates the necessary RPL amount to\n * bring the stake ratio back to the target. Then, the function either stakes the required RPL or stakes\n * the remaining RPL balance if it's not enough.\n * @param _NodeAccount The address of the node.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n */\n function performTopUp(address _NodeAccount, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(\n _NodeAccount\n );\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n uint256 requiredStakeRpl = minuend < rplStaked ? 0 : minuend - rplStaked;\n // Make sure the contract has enough RPL to stake\n uint256 currentRplBalance = RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n if (currentRplBalance >= requiredStakeRpl) {\n if (requiredStakeRpl == 0) {\n return;\n }\n // stakeRPLOnBehalfOf\n // transfer RPL to deposit pool\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n requiredStakeRpl\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, requiredStakeRpl);\n } else {\n if (currentRplBalance == 0) {\n return;\n }\n // stake what we have\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n currentRplBalance\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, currentRplBalance);\n }\n }\n }\n\n function performTopDown(address _nodeAddress, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(_nodeAddress);\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n uint256 excessRpl = rplStaked > maxRplStake ? rplStaked - maxRplStake : 0;\n\n if (excessRpl > 0) {\n fundedRpl -= excessRpl;\n FundRouter(_directory.getDepositPoolAddress()).unstakeRpl(_nodeAddress, excessRpl);\n\n // Update the amount of RPL funded by the node\n minipoolAmountFundedRpl[_nodeAddress] -= excessRpl;\n }\n }\n }\n\n /**\n * @notice Calculates the amount of RPL needed to top up the node operator's stake to the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it returns the necessary RPL amount to\n * bring the stake ratio back to the target.\n * @param _existingRplStake Prior crap staked\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return requiredStakeRpl The amount of RPL required to top up to the target stake ratio.\n */\n function calculateRequiredRplTopUp(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 requiredStakeRpl) {\n console.log('before calling getPriceFetcherAddress');\n console.logAddress(getDirectory().getPriceFetcherAddress());\n console.log('B');\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n console.log('price', ethPriceInRpl);\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n requiredStakeRpl = minuend < _existingRplStake ? 0 : minuend - _existingRplStake;\n } else {\n requiredStakeRpl = 0;\n }\n return requiredStakeRpl;\n }\n\n /**\n * @notice Calculates the amount of RPL that can be withdrawn from the node operator's stake without falling below the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is above a predefined target, it returns the maximum RPL amount that can be withdrawn\n * while still maintaining at least the target stake ratio.\n * @param _existingRplStake The amount of RPL currently staked by the node operator.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return withdrawableStakeRpl The maximum amount of RPL that can be withdrawn while maintaining the target stake ratio.\n */\n function calculateRequiredRplTopDown(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 withdrawableStakeRpl) {\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n withdrawableStakeRpl = _existingRplStake > maxRplStake ? _existingRplStake - maxRplStake : 0;\n } else {\n withdrawableStakeRpl = 0;\n }\n return withdrawableStakeRpl;\n }\n\n /**\n * @notice Processes rewards for a predefined number of minipools. This function is meant to be called during\n * the creation of new intervals. It serves to withdraw rewards from minipools and to top up the RPL stake.\n * @dev The function first checks if there are any minipools to process. If there aren't, it emits a warning event\n * and exits. Otherwise, it calls the internal function _processNextMinipool() for a certain number of times defined\n * by numMinipoolsProcessedPerInterval.\n */\n function processNextMinipool() external onlyProtocol {\n if (minipoolAddresses.length == 0) {\n emit WarningNoMiniPoolsToHarvest();\n return;\n }\n\n for (uint i = 0; i < numMinipoolsProcessedPerInterval; i++) {\n _processNextMinipool();\n }\n }\n\n function OnMinipoolCreated(address newMinipoolAddress, address nodeAddress, uint256 bond) external {\n if (!_directory.hasRole(Constants.CORE_PROTOCOL_ROLE, msg.sender)) {\n revert BadRole(Constants.CORE_PROTOCOL_ROLE, msg.sender);\n }\n\n // register minipool with node operator\n Whitelist whitelist = Whitelist(getDirectory().getWhitelistAddress());\n whitelist.registerNewValidator(nodeAddress);\n\n // new minipool owned by node operator\n nodeOperatorOwnedMinipools[nodeAddress].push(newMinipoolAddress);\n\n // add minipool to minipoolAddresses\n minipoolAddresses.push(newMinipoolAddress);\n minipoolIndexMap[newMinipoolAddress] = minipoolAddresses.length;\n\n emit MinipoolCreated(newMinipoolAddress, nodeAddress);\n\n // updated amount funded eth\n minipoolAmountFundedEth[newMinipoolAddress] = bond;\n }\n\n /**\n * @dev Processes a single minipool by performing RPL top-up and distributing balance if certain conditions are met.\n */\n function _processNextMinipool() internal {\n uint256 index = nextMinipoolHavestIndex % minipoolAddresses.length;\n IMinipool minipool = IMinipool(minipoolAddresses[index]);\n\n if (minipool.getStatus() != MinipoolStatus.Staking) {\n emit WarningMinipoolNotStaking(address(minipool), minipool.getStatus());\n return;\n }\n\n // process top up\n address nodeAddress = minipool.getNodeAddress();\n\n uint256 ethStaked = nodeOperatorEthStaked[nodeAddress];\n\n performTopUp(nodeAddress, ethStaked);\n performTopDown(nodeAddress, ethStaked);\n\n nextMinipoolHavestIndex = index + 1;\n\n uint256 balance = minipool.getNodeDepositBalance();\n minipool.distributeBalance(balance >= 8 ether);\n }\n\n /**\n * @notice Set the number of minipools to be processed per interval.\n * @dev This function can only be called by the contract's admin.\n * Adjusting this parameter allows the admin to control and optimize the load\n * on the network for each interval, especially in scenarios with a large number of minipools.\n * @param _numMinipoolsProcessedPerInterval The new number of minipools to process per interval.\n */\n function setNumMinipoolsProcessedPerInterval(uint256 _numMinipoolsProcessedPerInterval) external onlyAdmin {\n numMinipoolsProcessedPerInterval = _numMinipoolsProcessedPerInterval;\n }\n\n function setBondRequirments(uint256 _requiredLEBStaked) external onlyAdmin {\n requiredLEBStaked = _requiredLEBStaked;\n }\n\n function onNodeOperatorDissolved(address _nodeOperator, uint256 _bond) external onlyProtocol {\n fundedEth -= _bond;\n nodeOperatorEthStaked[_nodeOperator] -= _bond;\n }\n\n /**\n * @notice Retrieves the list of minipool addresses managed by the contract.\n * @dev This function provides a way to fetch all the current minipool addresses in memory.\n * Useful for off-chain services or frontend interfaces that need to display or interact\n * with the various minipools.\n * @return A list of addresses corresponding to the minipools.\n */\n function getMinipoolAddresses() external view returns (address[] memory) {\n return minipoolAddresses;\n }\n\n function transferWEthToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getWETHVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n address weth = _directory.getWETHAddress();\n\n // Check if there's enough WETH in the contract\n uint256 wethBalance = IWETH(weth).balanceOf(address(this));\n if (wethBalance >= _amount) {\n IWETH(weth).deposit{value: _amount}();\n SafeERC20.safeTransfer(IERC20(weth), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n\n function transferRplToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getRPLVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n\n // Check if there's enough RPL in the contract\n address rpl = IERC4626Upgradeable(vault).asset();\n uint256 rplBalance = IERC20(rpl).balanceOf(address(this));\n if (rplBalance >= _amount) {\n SafeERC20.safeTransfer(IERC20(rpl), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n}\n","line":76,"range":[2919,2953]},"functionType":3},{"type":23,"sourceReference":{"function":"log","contract":"OperatorDistributor","sourceName":"hardhat/console.sol","sourceContent":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n\n}\n","line":197,"range":[6141,6183]}}],"data":"0x"}, code=UNPREDICTABLE_GAS_LIMIT, version=providers/5.7.2) + Error: cannot estimate gas; transaction may fail or may require manual gas limit [ See: https://links.ethers.org/v5-errors-UNPREDICTABLE_GAS_LIMIT ] (reason="Transaction reverted: contract call run out of gas and made the transaction revert", method="estimateGas", transaction={"from":"0x1CBd3b2770909D4e10f157cABC84C7264073C9Ec","to":"0x10e38eE9dd4C549b61400Fc19347D00eD3edAfC4","value":{"type":"BigNumber","hex":"0x6f05b59d3b200000"},"accessList":null}, error={"stackTrace":[{"type":2,"address":{"type":"Buffer","data":[16,227,142,233,221,76,84,155,97,64,15,193,147,71,208,14,211,237,175,196]}},{"type":0,"sourceReference":{"function":"","contract":"OperatorDistributor","sourceName":"contracts/Operator/OperatorDistributor.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';\n\nimport '../UpgradeableBase.sol';\nimport '../Whitelist/Whitelist.sol';\nimport '../FundRouter.sol';\nimport '../PriceFetcher.sol';\nimport '../Tokens/WETHVault.sol';\n\nimport '../Utils/Constants.sol';\nimport '../Utils/Errors.sol';\n\nimport '../Interfaces/IWETH.sol';\nimport '../Interfaces/RocketPool/IRocketStorage.sol';\nimport '../Interfaces/RocketPool/IMinipool.sol';\nimport '../Interfaces/RocketPool/IRocketNodeManager.sol';\nimport '../Interfaces/RocketPool/IRocketNodeStaking.sol';\n\ncontract OperatorDistributor is UpgradeableBase, Errors {\n event MinipoolCreated(address indexed _minipoolAddress, address indexed _nodeAddress);\n event MinipoolDestroyed(address indexed _minipoolAddress, address indexed _nodeAddress);\n event WarningNoMiniPoolsToHarvest();\n event WarningMinipoolNotStaking(address indexed _minipoolAddress, MinipoolStatus indexed _status);\n\n using Math for uint256;\n\n // The total amount of Ether (ETH) funded or allocated by the contract.\n // This variable keeps track of the ETH resources managed within this contract,\n uint256 public fundedEth;\n\n // The total amount of Rocket Pool tokens (RPL) funded or allocated by the contract.\n // This field is used to track the RPL token balance managed by the contract,\n uint256 public fundedRpl;\n\n address[] public minipoolAddresses;\n\n uint256 public nextMinipoolHavestIndex;\n uint256 public targetStakeRatio;\n\n uint256 public numMinipoolsProcessedPerInterval;\n\n uint256 public requiredLEBStaked;\n\n mapping(address => uint256) public minipoolIndexMap;\n mapping(address => uint256) public minipoolAmountFundedEth;\n mapping(address => uint256) public minipoolAmountFundedRpl;\n\n mapping(address => address[]) public nodeOperatorOwnedMinipools;\n mapping(address => uint256) public nodeOperatorEthStaked;\n\n constructor() initializer {}\n\n /**\n * @notice Initializes the contract with the provided storage address.\n * @dev This function should only be called once, during contract creation or proxy initialization.\n * It overrides the `initialize` function from a parent contract.\n * @param _directory The address of the storage contract.\n */\n function initialize(address _directory) public override initializer {\n super.initialize(_directory);\n targetStakeRatio = 1.5e18; // 150%\n numMinipoolsProcessedPerInterval = 1;\n\n // defaulting these to 8eth to only allow LEB8 minipools\n requiredLEBStaked = 8 ether;\n }\n\n /**\n * @notice Receives incoming Ether and adds it to the queued balance.\n * @dev This is the fallback function that is called when Ether is sent directly to the contract.\n */\n receive() external payable {\n address payable dp = _directory.getDepositPoolAddress();\n console.log('fallback od initial');\n console.log(address(this).balance);\n\n if (msg.sender != dp) {\n (bool success, ) = dp.call{value: msg.value}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n }\n\n console.log('fallback od final');\n console.log(address(this).balance);\n }\n\n function _rebalanceLiquidity() internal nonReentrant {\n address payable dp = _directory.getDepositPoolAddress();\n (bool success, ) = dp.call{value: address(this).balance}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n\n IERC20 rpl = IERC20(_directory.getRPLAddress());\n SafeERC20.safeTransfer(rpl, dp, rpl.balanceOf(address(this)));\n FundRouter(dp).sendRplToDistributors();\n }\n\n /// @notice Gets the total ETH value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function sums up the balance of this contract with the amount of funded ETH across all minipools.\n /// Ensure that all sources of ETH (like the OperatorDistributor) are properly accounted for in the calculation.\n /// @return The total amount of Ether locked inside the protocol.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + fundedEth;\n }\n\n /// @notice Gets the total RPL value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function calculates the total RPL by summing up the balance of RPL tokens of this contract\n /// with the amount of funded RPL across all minipools. It retrieves the RPL token address from the `_directory` contract.\n /// Ensure that all sources of RPL (like the OperatorDistributor) are accurately accounted for.\n /// @return The total amount of RPL tokens locked inside the protocol.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this)) + fundedRpl;\n }\n\n /**\n * @notice Removes a minipool address from the tracked list when a node operator exits.\n * @dev This function efficiently reorders the minipool addresses array and updates the index map.\n * It then resets the funded amount of ETH and RPL tokens for the removed minipool.\n * Should only be called by authorized protocol actors or admin.\n * @param _address The address of the minipool to be removed.\n *\n * Emits a `MinipoolDestroyed` event upon successful removal.\n */ function removeMinipoolAddress(address _address) public onlyProtocolOrAdmin {\n uint index = minipoolIndexMap[_address] - 1;\n require(index < minipoolAddresses.length, 'Address not found.');\n\n // Move the last address into the spot located by index\n address lastAddress = minipoolAddresses[minipoolAddresses.length - 1];\n minipoolAddresses[index] = lastAddress;\n minipoolIndexMap[lastAddress] = index;\n\n // Remove the last address\n minipoolAddresses.pop();\n delete minipoolIndexMap[_address];\n\n // Set amount funded to 0 since it's being returned to DP\n minipoolAmountFundedEth[_address] = 0;\n minipoolAmountFundedRpl[_address] = 0;\n\n emit MinipoolDestroyed(_address, IMinipool(_address).getNodeAddress());\n }\n\n /**\n * @notice Removes a node operator and all associated minipools.\n * @dev Iterates through all minipools owned by the node operator and removes them.\n * This action cannot be reversed, so it should be executed with caution.\n * Only authorized protocol actors or admin can call this function.\n * @param _address The address of the node operator to be removed.\n */\n function removeNodeOperator(address _address) external onlyProtocolOrAdmin {\n // remove all minipools owned by node operator\n address[] memory minipools = nodeOperatorOwnedMinipools[_address];\n for (uint i = 0; i < minipools.length; i++) {\n removeMinipoolAddress(minipools[i]);\n }\n delete nodeOperatorOwnedMinipools[_address];\n }\n\n /**\n * @notice Stakes the minimum required RPL tokens on behalf of a node.\n * @dev This function first fetches the node's minimum RPL stake requirement,\n * approves the Node Staking contract to spend the RPL, and then stakes the RPL for the node.\n * It assumes that the contract already holds enough RPL tokens for the staking process.\n * @param _nodeAddress The address of the node for which RPL should be staked.\n */\n function _stakeRPLFor(address _nodeAddress) internal {\n IRocketNodeStaking nodeStaking = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress());\n uint256 minimumRplStake = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress())\n .getNodeMinimumRPLStake(_nodeAddress);\n\n fundedRpl += minimumRplStake;\n\n // approve the node staking contract to spend the RPL\n RocketTokenRPLInterface rpl = RocketTokenRPLInterface(_directory.getRPLAddress());\n require(rpl.approve(getDirectory().getRocketNodeStakingAddress(), minimumRplStake));\n\n // update amount funded rpl\n minipoolAmountFundedRpl[_nodeAddress] = minimumRplStake;\n\n nodeStaking.stakeRPLFor(_nodeAddress, minimumRplStake);\n }\n\n /**\n * @notice Prepares a node for minipool creation by setting up necessary staking and validations.\n * @dev This function first validates the node's withdrawal address, then calculates the required amount of\n * RPL to stake based on the number of validators associated with the node, and performs a top-up.\n * Only the protocol or admin can call this function.\n * @param _NodeAccount The address of the validator account belonging to the Node Operator\n */\n function provisionLiquiditiesForMinipoolCreation(\n address _nodeOperator,\n address _NodeAccount,\n uint256 _bond\n ) external onlyProtocolOrAdmin {\n _rebalanceLiquidity();\n require(_bond == requiredLEBStaked, 'OperatorDistributor: Bad _bond amount, should be `requiredLEBStaked`');\n fundedEth += _bond;\n nodeOperatorEthStaked[_nodeOperator] += _bond;\n\n // by default this bonds 150% of stake according to max stake defined here: https://docs.rocketpool.net/guides/node/create-validator#staking-rpl\n // performTopUp(_NodeAccount, nodeOperatorEthStaked[_nodeOperator]);\n (bool success, bytes memory data) = _NodeAccount.call{value: _bond}('');\n if (!success) {\n revert LowLevelEthTransfer(success, data);\n }\n }\n\n /**\n * @notice Tops up the node operator's RPL stake if it falls below the target stake ratio.\n * @dev This function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it calculates the necessary RPL amount to\n * bring the stake ratio back to the target. Then, the function either stakes the required RPL or stakes\n * the remaining RPL balance if it's not enough.\n * @param _NodeAccount The address of the node.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n */\n function performTopUp(address _NodeAccount, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(\n _NodeAccount\n );\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n uint256 requiredStakeRpl = minuend < rplStaked ? 0 : minuend - rplStaked;\n // Make sure the contract has enough RPL to stake\n uint256 currentRplBalance = RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n if (currentRplBalance >= requiredStakeRpl) {\n if (requiredStakeRpl == 0) {\n return;\n }\n // stakeRPLOnBehalfOf\n // transfer RPL to deposit pool\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n requiredStakeRpl\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, requiredStakeRpl);\n } else {\n if (currentRplBalance == 0) {\n return;\n }\n // stake what we have\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n currentRplBalance\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, currentRplBalance);\n }\n }\n }\n\n function performTopDown(address _nodeAddress, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(_nodeAddress);\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n uint256 excessRpl = rplStaked > maxRplStake ? rplStaked - maxRplStake : 0;\n\n if (excessRpl > 0) {\n fundedRpl -= excessRpl;\n FundRouter(_directory.getDepositPoolAddress()).unstakeRpl(_nodeAddress, excessRpl);\n\n // Update the amount of RPL funded by the node\n minipoolAmountFundedRpl[_nodeAddress] -= excessRpl;\n }\n }\n }\n\n /**\n * @notice Calculates the amount of RPL needed to top up the node operator's stake to the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it returns the necessary RPL amount to\n * bring the stake ratio back to the target.\n * @param _existingRplStake Prior crap staked\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return requiredStakeRpl The amount of RPL required to top up to the target stake ratio.\n */\n function calculateRequiredRplTopUp(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 requiredStakeRpl) {\n console.log('before calling getPriceFetcherAddress');\n console.logAddress(getDirectory().getPriceFetcherAddress());\n console.log('B');\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n console.log('price', ethPriceInRpl);\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n requiredStakeRpl = minuend < _existingRplStake ? 0 : minuend - _existingRplStake;\n } else {\n requiredStakeRpl = 0;\n }\n return requiredStakeRpl;\n }\n\n /**\n * @notice Calculates the amount of RPL that can be withdrawn from the node operator's stake without falling below the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is above a predefined target, it returns the maximum RPL amount that can be withdrawn\n * while still maintaining at least the target stake ratio.\n * @param _existingRplStake The amount of RPL currently staked by the node operator.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return withdrawableStakeRpl The maximum amount of RPL that can be withdrawn while maintaining the target stake ratio.\n */\n function calculateRequiredRplTopDown(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 withdrawableStakeRpl) {\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n withdrawableStakeRpl = _existingRplStake > maxRplStake ? _existingRplStake - maxRplStake : 0;\n } else {\n withdrawableStakeRpl = 0;\n }\n return withdrawableStakeRpl;\n }\n\n /**\n * @notice Processes rewards for a predefined number of minipools. This function is meant to be called during\n * the creation of new intervals. It serves to withdraw rewards from minipools and to top up the RPL stake.\n * @dev The function first checks if there are any minipools to process. If there aren't, it emits a warning event\n * and exits. Otherwise, it calls the internal function _processNextMinipool() for a certain number of times defined\n * by numMinipoolsProcessedPerInterval.\n */\n function processNextMinipool() external onlyProtocol {\n if (minipoolAddresses.length == 0) {\n emit WarningNoMiniPoolsToHarvest();\n return;\n }\n\n for (uint i = 0; i < numMinipoolsProcessedPerInterval; i++) {\n _processNextMinipool();\n }\n }\n\n function OnMinipoolCreated(address newMinipoolAddress, address nodeAddress, uint256 bond) external {\n if (!_directory.hasRole(Constants.CORE_PROTOCOL_ROLE, msg.sender)) {\n revert BadRole(Constants.CORE_PROTOCOL_ROLE, msg.sender);\n }\n\n // register minipool with node operator\n Whitelist whitelist = Whitelist(getDirectory().getWhitelistAddress());\n whitelist.registerNewValidator(nodeAddress);\n\n // new minipool owned by node operator\n nodeOperatorOwnedMinipools[nodeAddress].push(newMinipoolAddress);\n\n // add minipool to minipoolAddresses\n minipoolAddresses.push(newMinipoolAddress);\n minipoolIndexMap[newMinipoolAddress] = minipoolAddresses.length;\n\n emit MinipoolCreated(newMinipoolAddress, nodeAddress);\n\n // updated amount funded eth\n minipoolAmountFundedEth[newMinipoolAddress] = bond;\n }\n\n /**\n * @dev Processes a single minipool by performing RPL top-up and distributing balance if certain conditions are met.\n */\n function _processNextMinipool() internal {\n uint256 index = nextMinipoolHavestIndex % minipoolAddresses.length;\n IMinipool minipool = IMinipool(minipoolAddresses[index]);\n\n if (minipool.getStatus() != MinipoolStatus.Staking) {\n emit WarningMinipoolNotStaking(address(minipool), minipool.getStatus());\n return;\n }\n\n // process top up\n address nodeAddress = minipool.getNodeAddress();\n\n uint256 ethStaked = nodeOperatorEthStaked[nodeAddress];\n\n performTopUp(nodeAddress, ethStaked);\n performTopDown(nodeAddress, ethStaked);\n\n nextMinipoolHavestIndex = index + 1;\n\n uint256 balance = minipool.getNodeDepositBalance();\n minipool.distributeBalance(balance >= 8 ether);\n }\n\n /**\n * @notice Set the number of minipools to be processed per interval.\n * @dev This function can only be called by the contract's admin.\n * Adjusting this parameter allows the admin to control and optimize the load\n * on the network for each interval, especially in scenarios with a large number of minipools.\n * @param _numMinipoolsProcessedPerInterval The new number of minipools to process per interval.\n */\n function setNumMinipoolsProcessedPerInterval(uint256 _numMinipoolsProcessedPerInterval) external onlyAdmin {\n numMinipoolsProcessedPerInterval = _numMinipoolsProcessedPerInterval;\n }\n\n function setBondRequirments(uint256 _requiredLEBStaked) external onlyAdmin {\n requiredLEBStaked = _requiredLEBStaked;\n }\n\n function onNodeMinipoolDestroy(address _nodeOperator, uint256 _bond) external onlyProtocol {\n fundedEth -= _bond;\n nodeOperatorEthStaked[_nodeOperator] -= _bond;\n }\n\n /**\n * @notice Retrieves the list of minipool addresses managed by the contract.\n * @dev This function provides a way to fetch all the current minipool addresses in memory.\n * Useful for off-chain services or frontend interfaces that need to display or interact\n * with the various minipools.\n * @return A list of addresses corresponding to the minipools.\n */\n function getMinipoolAddresses() external view returns (address[] memory) {\n return minipoolAddresses;\n }\n\n function transferWEthToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getWETHVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n address weth = _directory.getWETHAddress();\n\n // Check if there's enough WETH in the contract\n uint256 wethBalance = IWETH(weth).balanceOf(address(this));\n if (wethBalance >= _amount) {\n IWETH(weth).deposit{value: _amount}();\n SafeERC20.safeTransfer(IERC20(weth), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n\n function transferRplToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getRPLVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n\n // Check if there's enough RPL in the contract\n address rpl = IERC4626Upgradeable(vault).asset();\n uint256 rplBalance = IERC20(rpl).balanceOf(address(this));\n if (rplBalance >= _amount) {\n SafeERC20.safeTransfer(IERC20(rpl), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n}\n","line":82,"range":[3167,3206]},"functionType":3},{"type":2,"address":{"type":"Buffer","data":[38,46,43,80,33,150,32,34,108,95,181,149,100,50,168,143,255,217,75,167]}},{"type":0,"sourceReference":{"function":"sendEthToDistributors","contract":"FundRouter","sourceName":"contracts/FundRouter.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/Strings.sol';\n\nimport './UpgradeableBase.sol';\nimport './Operator/OperatorDistributor.sol';\nimport './Operator/YieldDistributor.sol';\nimport './Interfaces/RocketPool/IRocketNodeStaking.sol';\nimport './Tokens/WETHVault.sol';\nimport './Tokens/RPLVault.sol';\n\nimport './Interfaces/IWETH.sol';\nimport './Utils/Constants.sol';\n\n/// @custom:security-contact info@nodeoperator.org\n/// @notice Immutable deposit pool which holds deposits and provides a minimum source of liquidity for depositors.\n/// ETH + RPL intakes from token mints and validator yields and sends to respective ERC4246 vaults.\ncontract FundRouter is UpgradeableBase {\n constructor() initializer {}\n\n /// @dev Initializes the FundRouter contract with the specified directory address.\n /// @param directoryAddress The address of the directory contract.\n function initialize(address directoryAddress) public virtual override initializer {\n super.initialize(directoryAddress);\n }\n\n ///--------\n /// GETTERS\n ///--------\n\n /// @notice Retrieves the total ETH and WETH value locked inside this deposit pool.\n /// @dev This function calculates and returns the combined value of ETH and WETH held by the deposit pool.\n /// It sums the ETH balance of this contract and the WETH balance from the WETH contract.\n /// @return The total value in ETH and WETH locked in the deposit pool.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + IWETH(_directory.getWETHAddress()).balanceOf(address(this));\n }\n\n /// @notice Retrieves the total RPL value locked inside this deposit pool.\n /// @dev This function calculates and returns the total amount of RPL tokens held by the deposit pool.\n /// @return The total value in RPL locked in the deposit pool.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n }\n\n ///--------\n /// ACTIONS\n ///--------\n\n /// @notice Unstakes a specified amount of RPL tokens.\n /// @dev This function allows an administrator to unstake a specified amount of RPL tokens from the Rocket Node Staking contract.\n /// @param _excessRpl The amount of RPL tokens to unstake.\n /// @dev The tokens will be withdrawn from the Rocket Node Staking contract.\n function unstakeRpl(address _nodeAddress, uint256 _excessRpl) external onlyAdmin {\n IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress()).withdrawRPL(_nodeAddress, _excessRpl);\n }\n\n /// @notice Stakes a specified amount of RPL tokens on behalf of a node operator.\n /// @dev This function allows the protocol or an administrator to stake a specified amount of RPL tokens on behalf of a node operator\n /// using the Rocket Node Staking contract.\n /// @param _nodeAddress The address of the node operator on whose behalf the RPL tokens are being staked.\n /// @param _amount The amount of RPL tokens to stake.\n /// @dev This function ensures that the specified amount of RPL tokens is approved and then staked for the given node operator.\n function stakeRPLFor(address _nodeAddress, uint256 _amount) external onlyProtocolOrAdmin {\n SafeERC20.safeApprove(\n RocketTokenRPLInterface(_directory.getRPLAddress()),\n _directory.getRocketNodeStakingAddress(),\n 0\n );\n SafeERC20.safeApprove(\n RocketTokenRPLInterface(_directory.getRPLAddress()),\n _directory.getRocketNodeStakingAddress(),\n _amount\n );\n IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).stakeRPLFor(_nodeAddress, _amount);\n }\n\n function sendEthToDistributors() public {\n console.log('sendEthToDistributors.A');\n // Convert entire WETH balance of this contract to ETH\n IWETH WETH = IWETH(_directory.getWETHAddress());\n uint256 wethBalance = WETH.balanceOf(address(this));\n WETH.withdraw(wethBalance);\n console.log('sendEthToDistributors.B');\n\n // Initialize the vault and operator distributor addresses\n WETHVault vweth = WETHVault(getDirectory().getWETHVaultAddress());\n address payable operatorDistributor = payable(getDirectory().getOperatorDistributorAddress());\n console.log('sendEthToDistributors.C');\n\n // Calculate required capital and total balance\n uint256 requiredCapital = vweth.getRequiredCollateral();\n uint256 ethBalance = address(this).balance;\n console.log('sendEthToDistributors.D');\n\n if (ethBalance >= requiredCapital) {\n console.log('sendEthToDistributors.E');\n\n // Send required capital in WETH to vault and surplus ETH to operator distributor\n WETH.deposit{value: requiredCapital}();\n console.log('sendEthToDistributors.E1');\n\n SafeERC20.safeTransfer(WETH, address(vweth), requiredCapital);\n console.log('sendEthToDistributors.E2');\n\n uint256 surplus = ethBalance - requiredCapital;\n console.log('sendEthToDistributors.E3');\n\n operatorDistributor.transfer(surplus);\n console.log('sendEthToDistributors.F');\n } else {\n console.log('sendEthToDistributors.G');\n\n // If not enough ETH balance, convert the shortfall in WETH back to ETH and send it\n uint256 shortfall = requiredCapital - ethBalance;\n WETH.deposit{value: shortfall}();\n SafeERC20.safeTransfer(IERC20(address(WETH)), address(vweth), requiredCapital);\n console.log('sendEthToDistributors.H');\n }\n console.log('sendEthToDistributors.I');\n }\n\n function sendRplToDistributors() public {\n console.log('sendRplToDistributors.A');\n\n // Initialize the RPLVault and the Operator Distributor addresses\n RPLVault vrpl = RPLVault(getDirectory().getRPLVaultAddress());\n address operatorDistributor = getDirectory().getOperatorDistributorAddress();\n RocketTokenRPLInterface RPL = RocketTokenRPLInterface(_directory.getRPLAddress());\n console.log('sendRplToDistributors.B');\n\n // Fetch the required capital in RPL and the total RPL balance of the contract\n uint256 requiredCapital = vrpl.getRequiredCollateral();\n uint256 totalBalance = RPL.balanceOf(address(this));\n console.log('sendRplToDistributors.C');\n\n // Determine the amount to send to the RPLVault\n uint256 toRplVault = (totalBalance >= requiredCapital) ? requiredCapital : totalBalance;\n console.log('sendRplToDistributors.D');\n\n // Transfer RPL to the RPLVault\n if (toRplVault > 0) {\n console.log('sendRplToDistributors.E');\n\n SafeERC20.safeTransfer(IERC20(address(RPL)), address(vrpl), toRplVault);\n }\n\n // Transfer any surplus RPL to the Operator Distributor\n if (totalBalance > toRplVault) {\n console.log('sendRplToDistributors.F');\n\n SafeERC20.safeTransfer(IERC20(address(RPL)), operatorDistributor, totalBalance - toRplVault);\n }\n console.log('sendRplToDistributors.G');\n }\n\n /// @notice Receive hook for ETH deposits.\n /// @dev This function allows the contract to receive ETH deposits sent to its address.\n /// It is used as a fallback function to accept incoming ETH transfers.\n receive() external payable {}\n}\n","line":110,"range":[5213,5250]},"functionType":1},{"type":2,"address":{"type":"Buffer","data":[16,227,142,233,221,76,84,155,97,64,15,193,147,71,208,14,211,237,175,196]}},{"type":0,"sourceReference":{"function":"","contract":"OperatorDistributor","sourceName":"contracts/Operator/OperatorDistributor.sol","sourceContent":"// SPDX-License-Identifier: GPL v3\npragma solidity 0.8.17;\n\nimport '@openzeppelin/contracts/utils/cryptography/ECDSA.sol';\n\nimport '../UpgradeableBase.sol';\nimport '../Whitelist/Whitelist.sol';\nimport '../FundRouter.sol';\nimport '../PriceFetcher.sol';\nimport '../Tokens/WETHVault.sol';\n\nimport '../Utils/Constants.sol';\nimport '../Utils/Errors.sol';\n\nimport '../Interfaces/IWETH.sol';\nimport '../Interfaces/RocketPool/IRocketStorage.sol';\nimport '../Interfaces/RocketPool/IMinipool.sol';\nimport '../Interfaces/RocketPool/IRocketNodeManager.sol';\nimport '../Interfaces/RocketPool/IRocketNodeStaking.sol';\n\ncontract OperatorDistributor is UpgradeableBase, Errors {\n event MinipoolCreated(address indexed _minipoolAddress, address indexed _nodeAddress);\n event MinipoolDestroyed(address indexed _minipoolAddress, address indexed _nodeAddress);\n event WarningNoMiniPoolsToHarvest();\n event WarningMinipoolNotStaking(address indexed _minipoolAddress, MinipoolStatus indexed _status);\n\n using Math for uint256;\n\n // The total amount of Ether (ETH) funded or allocated by the contract.\n // This variable keeps track of the ETH resources managed within this contract,\n uint256 public fundedEth;\n\n // The total amount of Rocket Pool tokens (RPL) funded or allocated by the contract.\n // This field is used to track the RPL token balance managed by the contract,\n uint256 public fundedRpl;\n\n address[] public minipoolAddresses;\n\n uint256 public nextMinipoolHavestIndex;\n uint256 public targetStakeRatio;\n\n uint256 public numMinipoolsProcessedPerInterval;\n\n uint256 public requiredLEBStaked;\n\n mapping(address => uint256) public minipoolIndexMap;\n mapping(address => uint256) public minipoolAmountFundedEth;\n mapping(address => uint256) public minipoolAmountFundedRpl;\n\n mapping(address => address[]) public nodeOperatorOwnedMinipools;\n mapping(address => uint256) public nodeOperatorEthStaked;\n\n constructor() initializer {}\n\n /**\n * @notice Initializes the contract with the provided storage address.\n * @dev This function should only be called once, during contract creation or proxy initialization.\n * It overrides the `initialize` function from a parent contract.\n * @param _directory The address of the storage contract.\n */\n function initialize(address _directory) public override initializer {\n super.initialize(_directory);\n targetStakeRatio = 1.5e18; // 150%\n numMinipoolsProcessedPerInterval = 1;\n\n // defaulting these to 8eth to only allow LEB8 minipools\n requiredLEBStaked = 8 ether;\n }\n\n /**\n * @notice Receives incoming Ether and adds it to the queued balance.\n * @dev This is the fallback function that is called when Ether is sent directly to the contract.\n */\n receive() external payable {\n address payable dp = _directory.getDepositPoolAddress();\n console.log('fallback od initial');\n console.log(address(this).balance);\n\n if (msg.sender != dp) {\n (bool success, ) = dp.call{value: msg.value}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n }\n\n console.log('fallback od final');\n console.log(address(this).balance);\n }\n\n function _rebalanceLiquidity() internal nonReentrant {\n address payable dp = _directory.getDepositPoolAddress();\n (bool success, ) = dp.call{value: address(this).balance}('');\n require(success, 'low level call failed in od');\n FundRouter(dp).sendEthToDistributors();\n\n IERC20 rpl = IERC20(_directory.getRPLAddress());\n SafeERC20.safeTransfer(rpl, dp, rpl.balanceOf(address(this)));\n FundRouter(dp).sendRplToDistributors();\n }\n\n /// @notice Gets the total ETH value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function sums up the balance of this contract with the amount of funded ETH across all minipools.\n /// Ensure that all sources of ETH (like the OperatorDistributor) are properly accounted for in the calculation.\n /// @return The total amount of Ether locked inside the protocol.\n function getTvlEth() public view returns (uint) {\n return address(this).balance + fundedEth;\n }\n\n /// @notice Gets the total RPL value locked inside the protocol, including inside of validators, the OperatorDistributor,\n /// and this contract.\n /// @dev This function calculates the total RPL by summing up the balance of RPL tokens of this contract\n /// with the amount of funded RPL across all minipools. It retrieves the RPL token address from the `_directory` contract.\n /// Ensure that all sources of RPL (like the OperatorDistributor) are accurately accounted for.\n /// @return The total amount of RPL tokens locked inside the protocol.\n function getTvlRpl() public view returns (uint) {\n return RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this)) + fundedRpl;\n }\n\n /**\n * @notice Removes a minipool address from the tracked list when a node operator exits.\n * @dev This function efficiently reorders the minipool addresses array and updates the index map.\n * It then resets the funded amount of ETH and RPL tokens for the removed minipool.\n * Should only be called by authorized protocol actors or admin.\n * @param _address The address of the minipool to be removed.\n *\n * Emits a `MinipoolDestroyed` event upon successful removal.\n */ function removeMinipoolAddress(address _address) public onlyProtocolOrAdmin {\n uint index = minipoolIndexMap[_address] - 1;\n require(index < minipoolAddresses.length, 'Address not found.');\n\n // Move the last address into the spot located by index\n address lastAddress = minipoolAddresses[minipoolAddresses.length - 1];\n minipoolAddresses[index] = lastAddress;\n minipoolIndexMap[lastAddress] = index;\n\n // Remove the last address\n minipoolAddresses.pop();\n delete minipoolIndexMap[_address];\n\n // Set amount funded to 0 since it's being returned to DP\n minipoolAmountFundedEth[_address] = 0;\n minipoolAmountFundedRpl[_address] = 0;\n\n emit MinipoolDestroyed(_address, IMinipool(_address).getNodeAddress());\n }\n\n /**\n * @notice Removes a node operator and all associated minipools.\n * @dev Iterates through all minipools owned by the node operator and removes them.\n * This action cannot be reversed, so it should be executed with caution.\n * Only authorized protocol actors or admin can call this function.\n * @param _address The address of the node operator to be removed.\n */\n function removeNodeOperator(address _address) external onlyProtocolOrAdmin {\n // remove all minipools owned by node operator\n address[] memory minipools = nodeOperatorOwnedMinipools[_address];\n for (uint i = 0; i < minipools.length; i++) {\n removeMinipoolAddress(minipools[i]);\n }\n delete nodeOperatorOwnedMinipools[_address];\n }\n\n /**\n * @notice Stakes the minimum required RPL tokens on behalf of a node.\n * @dev This function first fetches the node's minimum RPL stake requirement,\n * approves the Node Staking contract to spend the RPL, and then stakes the RPL for the node.\n * It assumes that the contract already holds enough RPL tokens for the staking process.\n * @param _nodeAddress The address of the node for which RPL should be staked.\n */\n function _stakeRPLFor(address _nodeAddress) internal {\n IRocketNodeStaking nodeStaking = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress());\n uint256 minimumRplStake = IRocketNodeStaking(getDirectory().getRocketNodeStakingAddress())\n .getNodeMinimumRPLStake(_nodeAddress);\n\n fundedRpl += minimumRplStake;\n\n // approve the node staking contract to spend the RPL\n RocketTokenRPLInterface rpl = RocketTokenRPLInterface(_directory.getRPLAddress());\n require(rpl.approve(getDirectory().getRocketNodeStakingAddress(), minimumRplStake));\n\n // update amount funded rpl\n minipoolAmountFundedRpl[_nodeAddress] = minimumRplStake;\n\n nodeStaking.stakeRPLFor(_nodeAddress, minimumRplStake);\n }\n\n /**\n * @notice Prepares a node for minipool creation by setting up necessary staking and validations.\n * @dev This function first validates the node's withdrawal address, then calculates the required amount of\n * RPL to stake based on the number of validators associated with the node, and performs a top-up.\n * Only the protocol or admin can call this function.\n * @param _NodeAccount The address of the validator account belonging to the Node Operator\n */\n function provisionLiquiditiesForMinipoolCreation(\n address _nodeOperator,\n address _NodeAccount,\n uint256 _bond\n ) external onlyProtocolOrAdmin {\n _rebalanceLiquidity();\n require(_bond == requiredLEBStaked, 'OperatorDistributor: Bad _bond amount, should be `requiredLEBStaked`');\n fundedEth += _bond;\n nodeOperatorEthStaked[_nodeOperator] += _bond;\n\n // by default this bonds 150% of stake according to max stake defined here: https://docs.rocketpool.net/guides/node/create-validator#staking-rpl\n // performTopUp(_NodeAccount, nodeOperatorEthStaked[_nodeOperator]);\n (bool success, bytes memory data) = _NodeAccount.call{value: _bond}('');\n if (!success) {\n revert LowLevelEthTransfer(success, data);\n }\n }\n\n /**\n * @notice Tops up the node operator's RPL stake if it falls below the target stake ratio.\n * @dev This function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it calculates the necessary RPL amount to\n * bring the stake ratio back to the target. Then, the function either stakes the required RPL or stakes\n * the remaining RPL balance if it's not enough.\n * @param _NodeAccount The address of the node.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n */\n function performTopUp(address _NodeAccount, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(\n _NodeAccount\n );\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n uint256 requiredStakeRpl = minuend < rplStaked ? 0 : minuend - rplStaked;\n // Make sure the contract has enough RPL to stake\n uint256 currentRplBalance = RocketTokenRPLInterface(_directory.getRPLAddress()).balanceOf(address(this));\n if (currentRplBalance >= requiredStakeRpl) {\n if (requiredStakeRpl == 0) {\n return;\n }\n // stakeRPLOnBehalfOf\n // transfer RPL to deposit pool\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n requiredStakeRpl\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, requiredStakeRpl);\n } else {\n if (currentRplBalance == 0) {\n return;\n }\n // stake what we have\n RocketTokenRPLInterface(_directory.getRPLAddress()).transfer(\n _directory.getDepositPoolAddress(),\n currentRplBalance\n );\n FundRouter(_directory.getDepositPoolAddress()).stakeRPLFor(_NodeAccount, currentRplBalance);\n }\n }\n }\n\n function performTopDown(address _nodeAddress, uint256 _ethStaked) public onlyProtocolOrAdmin {\n uint256 rplStaked = IRocketNodeStaking(_directory.getRocketNodeStakingAddress()).getNodeRPLStake(_nodeAddress);\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = rplStaked == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / rplStaked;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n uint256 excessRpl = rplStaked > maxRplStake ? rplStaked - maxRplStake : 0;\n\n if (excessRpl > 0) {\n fundedRpl -= excessRpl;\n FundRouter(_directory.getDepositPoolAddress()).unstakeRpl(_nodeAddress, excessRpl);\n\n // Update the amount of RPL funded by the node\n minipoolAmountFundedRpl[_nodeAddress] -= excessRpl;\n }\n }\n }\n\n /**\n * @notice Calculates the amount of RPL needed to top up the node operator's stake to the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is below a predefined target, it returns the necessary RPL amount to\n * bring the stake ratio back to the target.\n * @param _existingRplStake Prior crap staked\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return requiredStakeRpl The amount of RPL required to top up to the target stake ratio.\n */\n function calculateRequiredRplTopUp(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 requiredStakeRpl) {\n console.log('before calling getPriceFetcherAddress');\n console.logAddress(getDirectory().getPriceFetcherAddress());\n console.log('B');\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n console.log('price', ethPriceInRpl);\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio < targetStakeRatio) {\n uint256 minuend = ((_ethStaked * ethPriceInRpl) / targetStakeRatio);\n requiredStakeRpl = minuend < _existingRplStake ? 0 : minuend - _existingRplStake;\n } else {\n requiredStakeRpl = 0;\n }\n return requiredStakeRpl;\n }\n\n /**\n * @notice Calculates the amount of RPL that can be withdrawn from the node operator's stake without falling below the target stake ratio.\n * @dev This view function checks the current staking ratio of the node (calculated as ETH staked times its price in RPL\n * divided by RPL staked). If the ratio is above a predefined target, it returns the maximum RPL amount that can be withdrawn\n * while still maintaining at least the target stake ratio.\n * @param _existingRplStake The amount of RPL currently staked by the node operator.\n * @param _ethStaked The amount of ETH currently staked by the node operator.\n * @return withdrawableStakeRpl The maximum amount of RPL that can be withdrawn while maintaining the target stake ratio.\n */\n function calculateRequiredRplTopDown(\n uint256 _existingRplStake,\n uint256 _ethStaked\n ) public view returns (uint256 withdrawableStakeRpl) {\n uint256 ethPriceInRpl = PriceFetcher(getDirectory().getPriceFetcherAddress()).getPrice();\n\n uint256 stakeRatio = _existingRplStake == 0 ? 1e18 : (_ethStaked * ethPriceInRpl * 1e18) / _existingRplStake;\n if (stakeRatio > targetStakeRatio) {\n uint256 maxRplStake = (_ethStaked * ethPriceInRpl) / targetStakeRatio;\n withdrawableStakeRpl = _existingRplStake > maxRplStake ? _existingRplStake - maxRplStake : 0;\n } else {\n withdrawableStakeRpl = 0;\n }\n return withdrawableStakeRpl;\n }\n\n /**\n * @notice Processes rewards for a predefined number of minipools. This function is meant to be called during\n * the creation of new intervals. It serves to withdraw rewards from minipools and to top up the RPL stake.\n * @dev The function first checks if there are any minipools to process. If there aren't, it emits a warning event\n * and exits. Otherwise, it calls the internal function _processNextMinipool() for a certain number of times defined\n * by numMinipoolsProcessedPerInterval.\n */\n function processNextMinipool() external onlyProtocol {\n if (minipoolAddresses.length == 0) {\n emit WarningNoMiniPoolsToHarvest();\n return;\n }\n\n for (uint i = 0; i < numMinipoolsProcessedPerInterval; i++) {\n _processNextMinipool();\n }\n }\n\n function OnMinipoolCreated(address newMinipoolAddress, address nodeAddress, uint256 bond) external {\n if (!_directory.hasRole(Constants.CORE_PROTOCOL_ROLE, msg.sender)) {\n revert BadRole(Constants.CORE_PROTOCOL_ROLE, msg.sender);\n }\n\n // register minipool with node operator\n Whitelist whitelist = Whitelist(getDirectory().getWhitelistAddress());\n whitelist.registerNewValidator(nodeAddress);\n\n // new minipool owned by node operator\n nodeOperatorOwnedMinipools[nodeAddress].push(newMinipoolAddress);\n\n // add minipool to minipoolAddresses\n minipoolAddresses.push(newMinipoolAddress);\n minipoolIndexMap[newMinipoolAddress] = minipoolAddresses.length;\n\n emit MinipoolCreated(newMinipoolAddress, nodeAddress);\n\n // updated amount funded eth\n minipoolAmountFundedEth[newMinipoolAddress] = bond;\n }\n\n /**\n * @dev Processes a single minipool by performing RPL top-up and distributing balance if certain conditions are met.\n */\n function _processNextMinipool() internal {\n uint256 index = nextMinipoolHavestIndex % minipoolAddresses.length;\n IMinipool minipool = IMinipool(minipoolAddresses[index]);\n\n if (minipool.getStatus() != MinipoolStatus.Staking) {\n emit WarningMinipoolNotStaking(address(minipool), minipool.getStatus());\n return;\n }\n\n // process top up\n address nodeAddress = minipool.getNodeAddress();\n\n uint256 ethStaked = nodeOperatorEthStaked[nodeAddress];\n\n performTopUp(nodeAddress, ethStaked);\n performTopDown(nodeAddress, ethStaked);\n\n nextMinipoolHavestIndex = index + 1;\n\n uint256 balance = minipool.getNodeDepositBalance();\n minipool.distributeBalance(balance >= 8 ether);\n }\n\n /**\n * @notice Set the number of minipools to be processed per interval.\n * @dev This function can only be called by the contract's admin.\n * Adjusting this parameter allows the admin to control and optimize the load\n * on the network for each interval, especially in scenarios with a large number of minipools.\n * @param _numMinipoolsProcessedPerInterval The new number of minipools to process per interval.\n */\n function setNumMinipoolsProcessedPerInterval(uint256 _numMinipoolsProcessedPerInterval) external onlyAdmin {\n numMinipoolsProcessedPerInterval = _numMinipoolsProcessedPerInterval;\n }\n\n function setBondRequirments(uint256 _requiredLEBStaked) external onlyAdmin {\n requiredLEBStaked = _requiredLEBStaked;\n }\n\n function onNodeMinipoolDestroy(address _nodeOperator, uint256 _bond) external onlyProtocol {\n fundedEth -= _bond;\n nodeOperatorEthStaked[_nodeOperator] -= _bond;\n }\n\n /**\n * @notice Retrieves the list of minipool addresses managed by the contract.\n * @dev This function provides a way to fetch all the current minipool addresses in memory.\n * Useful for off-chain services or frontend interfaces that need to display or interact\n * with the various minipools.\n * @return A list of addresses corresponding to the minipools.\n */\n function getMinipoolAddresses() external view returns (address[] memory) {\n return minipoolAddresses;\n }\n\n function transferWEthToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getWETHVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n address weth = _directory.getWETHAddress();\n\n // Check if there's enough WETH in the contract\n uint256 wethBalance = IWETH(weth).balanceOf(address(this));\n if (wethBalance >= _amount) {\n IWETH(weth).deposit{value: _amount}();\n SafeERC20.safeTransfer(IERC20(weth), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n\n function transferRplToVault(uint256 _amount) external returns (uint256) {\n address vault = _directory.getRPLVaultAddress();\n require(msg.sender == vault, 'caller must be vault');\n\n // Check if there's enough RPL in the contract\n address rpl = IERC4626Upgradeable(vault).asset();\n uint256 rplBalance = IERC20(rpl).balanceOf(address(this));\n if (rplBalance >= _amount) {\n SafeERC20.safeTransfer(IERC20(rpl), vault, _amount);\n return _amount;\n } else {\n return 0;\n }\n }\n}\n","line":76,"range":[2919,2953]},"functionType":3},{"type":23,"sourceReference":{"function":"log","contract":"OperatorDistributor","sourceName":"hardhat/console.sol","sourceContent":"// SPDX-License-Identifier: MIT\npragma solidity >=0.4.22 <0.9.0;\n\nlibrary console {\n address constant CONSOLE_ADDRESS =\n 0x000000000000000000636F6e736F6c652e6c6f67;\n\n function _sendLogPayloadImplementation(bytes memory payload) internal view {\n address consoleAddress = CONSOLE_ADDRESS;\n /// @solidity memory-safe-assembly\n assembly {\n pop(\n staticcall(\n gas(),\n consoleAddress,\n add(payload, 32),\n mload(payload),\n 0,\n 0\n )\n )\n }\n }\n\n function _castToPure(\n function(bytes memory) internal view fnIn\n ) internal pure returns (function(bytes memory) pure fnOut) {\n assembly {\n fnOut := fnIn\n }\n }\n\n function _sendLogPayload(bytes memory payload) internal pure {\n _castToPure(_sendLogPayloadImplementation)(payload);\n }\n\n function log() internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log()\"));\n }\n function logInt(int256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(int256)\", p0));\n }\n\n function logUint(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function logString(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function logBool(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function logAddress(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function logBytes(bytes memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes)\", p0));\n }\n\n function logBytes1(bytes1 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes1)\", p0));\n }\n\n function logBytes2(bytes2 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes2)\", p0));\n }\n\n function logBytes3(bytes3 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes3)\", p0));\n }\n\n function logBytes4(bytes4 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes4)\", p0));\n }\n\n function logBytes5(bytes5 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes5)\", p0));\n }\n\n function logBytes6(bytes6 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes6)\", p0));\n }\n\n function logBytes7(bytes7 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes7)\", p0));\n }\n\n function logBytes8(bytes8 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes8)\", p0));\n }\n\n function logBytes9(bytes9 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes9)\", p0));\n }\n\n function logBytes10(bytes10 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes10)\", p0));\n }\n\n function logBytes11(bytes11 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes11)\", p0));\n }\n\n function logBytes12(bytes12 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes12)\", p0));\n }\n\n function logBytes13(bytes13 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes13)\", p0));\n }\n\n function logBytes14(bytes14 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes14)\", p0));\n }\n\n function logBytes15(bytes15 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes15)\", p0));\n }\n\n function logBytes16(bytes16 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes16)\", p0));\n }\n\n function logBytes17(bytes17 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes17)\", p0));\n }\n\n function logBytes18(bytes18 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes18)\", p0));\n }\n\n function logBytes19(bytes19 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes19)\", p0));\n }\n\n function logBytes20(bytes20 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes20)\", p0));\n }\n\n function logBytes21(bytes21 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes21)\", p0));\n }\n\n function logBytes22(bytes22 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes22)\", p0));\n }\n\n function logBytes23(bytes23 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes23)\", p0));\n }\n\n function logBytes24(bytes24 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes24)\", p0));\n }\n\n function logBytes25(bytes25 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes25)\", p0));\n }\n\n function logBytes26(bytes26 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes26)\", p0));\n }\n\n function logBytes27(bytes27 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes27)\", p0));\n }\n\n function logBytes28(bytes28 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes28)\", p0));\n }\n\n function logBytes29(bytes29 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes29)\", p0));\n }\n\n function logBytes30(bytes30 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes30)\", p0));\n }\n\n function logBytes31(bytes31 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes31)\", p0));\n }\n\n function logBytes32(bytes32 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bytes32)\", p0));\n }\n\n function log(uint256 p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256)\", p0));\n }\n\n function log(string memory p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string)\", p0));\n }\n\n function log(bool p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool)\", p0));\n }\n\n function log(address p0) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address)\", p0));\n }\n\n function log(uint256 p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256)\", p0, p1));\n }\n\n function log(uint256 p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string)\", p0, p1));\n }\n\n function log(uint256 p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool)\", p0, p1));\n }\n\n function log(uint256 p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address)\", p0, p1));\n }\n\n function log(string memory p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256)\", p0, p1));\n }\n\n function log(string memory p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string)\", p0, p1));\n }\n\n function log(string memory p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool)\", p0, p1));\n }\n\n function log(string memory p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address)\", p0, p1));\n }\n\n function log(bool p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256)\", p0, p1));\n }\n\n function log(bool p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string)\", p0, p1));\n }\n\n function log(bool p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool)\", p0, p1));\n }\n\n function log(bool p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address)\", p0, p1));\n }\n\n function log(address p0, uint256 p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256)\", p0, p1));\n }\n\n function log(address p0, string memory p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string)\", p0, p1));\n }\n\n function log(address p0, bool p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool)\", p0, p1));\n }\n\n function log(address p0, address p1) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address)\", p0, p1));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool)\", p0, p1, p2));\n }\n\n function log(uint256 p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool)\", p0, p1, p2));\n }\n\n function log(string memory p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool)\", p0, p1, p2));\n }\n\n function log(bool p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool)\", p0, p1, p2));\n }\n\n function log(address p0, uint256 p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool)\", p0, p1, p2));\n }\n\n function log(address p0, string memory p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool)\", p0, p1, p2));\n }\n\n function log(address p0, bool p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, uint256 p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, string memory p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, bool p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool)\", p0, p1, p2));\n }\n\n function log(address p0, address p1, address p2) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address)\", p0, p1, p2));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(uint256 p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(uint256,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(string memory p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(string,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(bool p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(bool,address,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, uint256 p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,uint256,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, string memory p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,string,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, bool p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,bool,address,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, uint256 p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,uint256,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, string memory p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,string,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, bool p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,bool,address)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, uint256 p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,uint256)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, string memory p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,string)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, bool p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,bool)\", p0, p1, p2, p3));\n }\n\n function log(address p0, address p1, address p2, address p3) internal pure {\n _sendLogPayload(abi.encodeWithSignature(\"log(address,address,address,address)\", p0, p1, p2, p3));\n }\n\n}\n","line":197,"range":[6141,6183]}}],"data":"0x"}, code=UNPREDICTABLE_GAS_LIMIT, version=providers/5.7.2) at Logger.makeError (node_modules/@ethersproject/logger/src.ts/index.ts:269:28) at Logger.throwError (node_modules/@ethersproject/logger/src.ts/index.ts:281:20) at checkError (node_modules/@ethersproject/providers/src.ts/json-rpc-provider.ts:78:20)