From 5d0b71cb1c4d7a9d223dcdb5cff0723b798da12b Mon Sep 17 00:00:00 2001 From: owen-eth Date: Mon, 23 Mar 2026 02:15:15 -0400 Subject: [PATCH 1/4] feat: reputation bidders and bidopts fix --- contracts/contracts/core/PreconfManager.sol | 4 +- .../contracts/core/PreconfManagerStorage.sol | 3 + contracts/contracts/core/ProviderRegistry.sol | 108 ++- .../core/ProviderRegistryStorage.sol | 14 +- .../interfaces/IProviderRegistry.sol | 15 +- .../test/core/ReputationProviderTest.sol | 645 ++++++++++++++++++ .../pkg/updater/position_constraint_test.go | 198 ++++++ oracle/pkg/updater/updater.go | 4 +- oracle/pkg/updater/updater_test.go | 2 +- tools/preconf-rpc/backrunner/backrunner.go | 1 + 10 files changed, 984 insertions(+), 10 deletions(-) create mode 100644 contracts/test/core/ReputationProviderTest.sol create mode 100644 oracle/pkg/updater/position_constraint_test.go diff --git a/contracts/contracts/core/PreconfManager.sol b/contracts/contracts/core/PreconfManager.sol index f882d88e0..73ba4662a 100644 --- a/contracts/contracts/core/PreconfManager.sol +++ b/contracts/contracts/core/PreconfManager.sol @@ -387,8 +387,10 @@ contract PreconfManager is commitment.isSettled = true; --commitmentsCount[commitment.committer]; + uint256 maxSlash = commitment.bidAmt * MAX_SLASH_BID_RATIO; + uint256 effectiveSlash = commitment.slashAmt > maxSlash ? maxSlash : commitment.slashAmt; providerRegistry.slash( - commitment.slashAmt, + effectiveSlash, commitment.committer, payable(commitment.bidder) ); diff --git a/contracts/contracts/core/PreconfManagerStorage.sol b/contracts/contracts/core/PreconfManagerStorage.sol index 571e8b41c..906f1b611 100644 --- a/contracts/contracts/core/PreconfManagerStorage.sol +++ b/contracts/contracts/core/PreconfManagerStorage.sol @@ -7,6 +7,9 @@ import {IBlockTracker} from "../interfaces/IBlockTracker.sol"; import {IPreconfManager} from "../interfaces/IPreconfManager.sol"; abstract contract PreconfManagerStorage { + /// @dev Maximum ratio of slash amount to bid amount + uint256 public constant MAX_SLASH_BID_RATIO = 100; + // Represents the dispatch window in milliseconds uint64 public commitmentDispatchWindow; diff --git a/contracts/contracts/core/ProviderRegistry.sol b/contracts/contracts/core/ProviderRegistry.sol index 2ef334601..3128717d0 100644 --- a/contracts/contracts/core/ProviderRegistry.sol +++ b/contracts/contracts/core/ProviderRegistry.sol @@ -249,6 +249,10 @@ contract ProviderRegistry is withdrawalRequests[msg.sender] == 0, UnstakeRequestExists(msg.sender) ); + require( + approverLockCount[msg.sender] == 0, + ApproverHasActiveReputationProviders(msg.sender, approverLockCount[msg.sender]) + ); withdrawalRequests[msg.sender] = block.timestamp; emit Unstake(msg.sender, block.timestamp); } @@ -272,6 +276,15 @@ contract ProviderRegistry is providerStakes[msg.sender] = 0; providerRegistered[msg.sender] = false; withdrawalRequests[msg.sender] = 0; + + // Clear reputation status if applicable + address approver = reputationProviderApprover[msg.sender]; + if (approver != address(0)) { + delete reputationProviderApprover[msg.sender]; + if (approver != owner()) { + --approverLockCount[approver]; + } + } require(preconfManager != address(0), PreconfManagerNotSet()); uint256 providerPendingCommitmentsCount = PreconfManager( @@ -408,12 +421,13 @@ contract ProviderRegistry is _registerAndStake(provider); } - /// @dev Ensure the provider's balance is greater than minStake and no pending withdrawal + /// @dev Ensure the provider's balance is greater than their applicable minStake and no pending withdrawal function isProviderValid(address provider) public view { uint256 providerStake = providerStakes[provider]; + uint256 effectiveMinStake = reputationProviderApprover[provider] != address(0) ? reputationMinStake : minStake; require( - providerStake >= minStake, - InsufficientStake(providerStake, minStake) + providerStake >= effectiveMinStake, + InsufficientStake(providerStake, effectiveMinStake) ); require( withdrawalRequests[provider] == 0, @@ -428,7 +442,8 @@ contract ProviderRegistry is for (uint256 i = 0; i < length; ++i) { address provider = providers[i]; bool isRegistered = providerRegistered[provider]; - bool hasStake = providerStakes[provider] >= minStake; + uint256 effectiveMinStake = reputationProviderApprover[provider] != address(0) ? reputationMinStake : minStake; + bool hasStake = providerStakes[provider] >= effectiveMinStake; bool noPendingWithdrawal = withdrawalRequests[provider] == 0; bool hasBLSKey = eoaToBlsPubkeys[provider].length > 0; validProviders[i] = isRegistered && hasStake && noPendingWithdrawal && hasBLSKey; @@ -476,6 +491,15 @@ contract ProviderRegistry is ); providerStakes[provider] += msg.value; emit FundsDeposited(provider, msg.value); + + // Auto-convert reputation provider to standard if they reach minStake + if (reputationProviderApprover[provider] != address(0) && providerStakes[provider] >= minStake) { + address approver = reputationProviderApprover[provider]; + delete reputationProviderApprover[provider]; + if (approver != owner()) { + --approverLockCount[approver]; + } + } } function _registerAndStake(address provider) internal { @@ -490,6 +514,82 @@ contract ProviderRegistry is emit ProviderRegistered(provider, msg.value); } + /// @dev Sets the minimum stake for reputation providers. Can only be called by the owner. + function setReputationMinStake(uint256 _reputationMinStake) external onlyOwner { + reputationMinStake = _reputationMinStake; + emit ReputationMinStakeUpdated(_reputationMinStake); + } + + /// @dev Request registration as a reputation provider. Must send >= reputationMinStake. + function requestReputationRegistration() external payable whenNotPaused { + require(!providerRegistered[msg.sender], ProviderAlreadyRegistered(msg.sender)); + require(pendingReputationStake[msg.sender] == 0, PendingReputationRequestExists(msg.sender)); + require(reputationMinStake != 0, InsufficientReputationStake(0, 0)); + require(msg.value >= reputationMinStake, InsufficientReputationStake(msg.value, reputationMinStake)); + + pendingReputationStake[msg.sender] = msg.value; + emit ReputationRegistrationRequested(msg.sender, msg.value); + } + + /// @dev Cancel a pending reputation registration request and get ETH back. + function cancelReputationRegistration() external nonReentrant whenNotPaused { + uint256 amount = pendingReputationStake[msg.sender]; + require(amount != 0, NoPendingReputationRequest(msg.sender)); + + delete pendingReputationStake[msg.sender]; + + (bool success, ) = msg.sender.call{value: amount}(""); + require(success, StakeTransferFailed(msg.sender, amount)); + + emit ReputationRegistrationCancelled(msg.sender, amount); + } + + /// @dev Approve a pending reputation provider. Callable by owner or a registered provider with >= minStake. + function approveReputationRegistration(address provider) external whenNotPaused { + uint256 amount = pendingReputationStake[provider]; + require(amount != 0, NoPendingReputationRequest(provider)); + + if (msg.sender != owner()) { + require(providerRegistered[msg.sender], ProviderNotRegistered(msg.sender)); + require(providerStakes[msg.sender] >= minStake, InsufficientStake(providerStakes[msg.sender], minStake)); + ++approverLockCount[msg.sender]; + } + + delete pendingReputationStake[provider]; + + providerStakes[provider] = amount; + providerRegistered[provider] = true; + reputationProviderApprover[provider] = msg.sender; + + emit ProviderRegistered(provider, amount); + emit ReputationProviderApproved(provider, msg.sender); + } + + /// @dev Remove a reputation provider. Callable by the approver or owner. + function removeReputationProvider(address provider) external whenNotPaused { + address approver = reputationProviderApprover[provider]; + require(approver != address(0), ProviderIsNotReputationProvider(provider)); + + require(msg.sender == approver, NotApprover(msg.sender)); + + delete reputationProviderApprover[provider]; + + if (approver != owner()) { + --approverLockCount[approver]; + } + + if (providerStakes[provider] == 0) { + // Fully slashed — just deregister + providerRegistered[provider] = false; + } else if (withdrawalRequests[provider] == 0) { + // Start the unstake process so they can withdraw after cooldown + withdrawalRequests[provider] = block.timestamp; + emit Unstake(provider, block.timestamp); + } + + emit ReputationProviderRemoved(provider, approver); + } + // solhint-disable-next-line no-empty-blocks function _authorizeUpgrade(address) internal override onlyOwner {} } diff --git a/contracts/contracts/core/ProviderRegistryStorage.sol b/contracts/contracts/core/ProviderRegistryStorage.sol index b3fe4fa48..b072bb4d9 100644 --- a/contracts/contracts/core/ProviderRegistryStorage.sol +++ b/contracts/contracts/core/ProviderRegistryStorage.sol @@ -44,6 +44,18 @@ abstract contract ProviderRegistryStorage { /// @dev Mapping from a provider's EOA address to their BLS public keys mapping(address => bytes[]) public eoaToBlsPubkeys; + /// @dev Minimum stake for reputation providers + uint256 public reputationMinStake; + + /// @dev Mapping from reputation provider to their approver (address(0) if not a reputation provider) + mapping(address => address) public reputationProviderApprover; + + /// @dev Mapping from provider to pending reputation registration stake + mapping(address => uint256) public pendingReputationStake; + + /// @dev Mapping from approver to number of active reputation providers they've approved + mapping(address => uint256) public approverLockCount; + /// @dev See https://docs.openzeppelin.com/upgrades-plugins/1.x/writing-upgradeable#storage-gaps - uint256[48] private __gap; + uint256[44] private __gap; } diff --git a/contracts/contracts/interfaces/IProviderRegistry.sol b/contracts/contracts/interfaces/IProviderRegistry.sol index 182d21feb..9ed577e8b 100644 --- a/contracts/contracts/interfaces/IProviderRegistry.sol +++ b/contracts/contracts/interfaces/IProviderRegistry.sol @@ -78,7 +78,20 @@ interface IProviderRegistry { error PublicKeyLengthInvalid(uint256 exp, uint256 got); error SignatureLengthInvalid(uint256 exp, uint256 got); error BLSSignatureInvalid(); - + error NoPendingReputationRequest(address provider); + error PendingReputationRequestExists(address provider); + error InsufficientReputationStake(uint256 stake, uint256 minStake); + error NotApproverOrOwner(address sender, address approver); + error ApproverHasActiveReputationProviders(address approver, uint256 count); + error ProviderIsNotReputationProvider(address provider); + error NotApprover(address sender); + + event ReputationRegistrationRequested(address indexed provider, uint256 stakedAmount); + event ReputationRegistrationCancelled(address indexed provider, uint256 returnedAmount); + event ReputationProviderApproved(address indexed provider, address indexed approver); + event ReputationProviderRemoved(address indexed provider, address indexed approver); + event ReputationMinStakeUpdated(uint256 indexed newMinStake); + function registerAndStake() external payable; function stake() external payable; diff --git a/contracts/test/core/ReputationProviderTest.sol b/contracts/test/core/ReputationProviderTest.sol new file mode 100644 index 000000000..924877309 --- /dev/null +++ b/contracts/test/core/ReputationProviderTest.sol @@ -0,0 +1,645 @@ +// SPDX-License-Identifier: BSL 1.1 +pragma solidity 0.8.26; + +import {Test} from "forge-std/Test.sol"; +import {ProviderRegistry} from "../../contracts/core/ProviderRegistry.sol"; +import {BidderRegistry} from "../../contracts/core/BidderRegistry.sol"; +import {PreconfManager} from "../../contracts/core/PreconfManager.sol"; +import {BlockTracker} from "../../contracts/core/BlockTracker.sol"; +import {Upgrades} from "openzeppelin-foundry-upgrades/Upgrades.sol"; +import {IProviderRegistry} from "../../contracts/interfaces/IProviderRegistry.sol"; +import {MockBLSVerify} from "../precompiles/BLSVerifyPreCompileMockTest.sol"; +import {DepositManager} from "../../contracts/core/DepositManager.sol"; + +contract ReputationProviderTest is Test { + ProviderRegistry public providerRegistry; + BidderRegistry public bidderRegistry; + PreconfManager public preconfManager; + BlockTracker public blockTracker; + + uint256 public minStake; + uint256 public reputationMinStake; + uint256 public feePercent; + uint256 public withdrawalDelay; + address public feeRecipient; + address public owner; + + address public standardProvider; + address public reputationProvider; + address public randomUser; + + event ProviderRegistered(address indexed provider, uint256 stakedAmount); + event ReputationRegistrationRequested(address indexed provider, uint256 stakedAmount); + event ReputationRegistrationCancelled(address indexed provider, uint256 returnedAmount); + event ReputationProviderApproved(address indexed provider, address indexed approver); + event ReputationProviderRemoved(address indexed provider, address indexed approver); + event Unstake(address indexed provider, uint256 timestamp); + + function setUp() public { + address BLS_VERIFY_ADDRESS = address(0xf0); + bytes memory code = type(MockBLSVerify).creationCode; + vm.etch(BLS_VERIFY_ADDRESS, code); + + owner = address(this); + minStake = 5 ether; + reputationMinStake = 0.01 ether; + feePercent = 10 * 1e16; + feeRecipient = vm.addr(9); + withdrawalDelay = 24 hours; + + address providerRegistryProxy = Upgrades.deployUUPSProxy( + "ProviderRegistry.sol", + abi.encodeCall( + ProviderRegistry.initialize, + (minStake, feeRecipient, feePercent, owner, withdrawalDelay, 10000) + ) + ); + providerRegistry = ProviderRegistry(payable(providerRegistryProxy)); + providerRegistry.setReputationMinStake(reputationMinStake); + + address blockTrackerProxy = Upgrades.deployUUPSProxy( + "BlockTracker.sol", + abi.encodeCall(BlockTracker.initialize, (owner, owner)) + ); + blockTracker = BlockTracker(payable(blockTrackerProxy)); + + address bidderRegistryProxy = Upgrades.deployUUPSProxy( + "BidderRegistry.sol", + abi.encodeCall( + BidderRegistry.initialize, + (feeRecipient, feePercent, owner, address(blockTracker), 10000, 10000) + ) + ); + bidderRegistry = BidderRegistry(payable(bidderRegistryProxy)); + + DepositManager depositManager = new DepositManager(address(bidderRegistry), 0.01 ether); + bidderRegistry.setDepositManagerImpl(address(depositManager)); + + address preconfManagerProxy = Upgrades.deployUUPSProxy( + "PreconfManager.sol", + abi.encodeCall( + PreconfManager.initialize, + (address(providerRegistry), address(bidderRegistry), address(blockTracker), feeRecipient, owner, 500) + ) + ); + preconfManager = PreconfManager(payable(preconfManagerProxy)); + providerRegistry.setPreconfManager(address(preconfManager)); + + standardProvider = vm.addr(1); + reputationProvider = vm.addr(2); + randomUser = vm.addr(3); + + vm.deal(standardProvider, 100 ether); + vm.deal(reputationProvider, 100 ether); + vm.deal(randomUser, 100 ether); + + // Register a standard provider + vm.prank(standardProvider); + providerRegistry.registerAndStake{value: 5 ether}(); + } + + // =========== Request Registration =========== + + function test_RequestReputationRegistration() public { + vm.prank(reputationProvider); + vm.expectEmit(true, false, false, true); + emit ReputationRegistrationRequested(reputationProvider, 0.01 ether); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + + assertEq(providerRegistry.pendingReputationStake(reputationProvider), 0.01 ether); + assertFalse(providerRegistry.providerRegistered(reputationProvider)); + } + + function test_RevertWhen_RequestWithInsufficientStake() public { + vm.prank(reputationProvider); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.InsufficientReputationStake.selector, 0.001 ether, reputationMinStake + )); + providerRegistry.requestReputationRegistration{value: 0.001 ether}(); + } + + function test_RevertWhen_RequestWhenAlreadyRegistered() public { + vm.prank(standardProvider); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.ProviderAlreadyRegistered.selector, standardProvider + )); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + } + + function test_RevertWhen_RequestWhenPendingExists() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + + vm.prank(reputationProvider); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.PendingReputationRequestExists.selector, reputationProvider + )); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + } + + function test_RevertWhen_RequestWithReputationMinStakeNotSet() public { + // Deploy fresh registry without setting reputationMinStake + address freshProxy = Upgrades.deployUUPSProxy( + "ProviderRegistry.sol", + abi.encodeCall( + ProviderRegistry.initialize, + (minStake, feeRecipient, feePercent, owner, withdrawalDelay, 10000) + ) + ); + ProviderRegistry freshRegistry = ProviderRegistry(payable(freshProxy)); + + vm.prank(reputationProvider); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.InsufficientReputationStake.selector, 0, 0 + )); + freshRegistry.requestReputationRegistration{value: 0.01 ether}(); + } + + // =========== Cancel Registration =========== + + function test_CancelReputationRegistration() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + + uint256 balanceBefore = reputationProvider.balance; + + vm.prank(reputationProvider); + vm.expectEmit(true, false, false, true); + emit ReputationRegistrationCancelled(reputationProvider, 0.01 ether); + providerRegistry.cancelReputationRegistration(); + + assertEq(providerRegistry.pendingReputationStake(reputationProvider), 0); + assertEq(reputationProvider.balance, balanceBefore + 0.01 ether); + } + + function test_RevertWhen_CancelWithNoPendingRequest() public { + vm.prank(reputationProvider); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.NoPendingReputationRequest.selector, reputationProvider + )); + providerRegistry.cancelReputationRegistration(); + } + + // =========== Approve Registration =========== + + function test_ApproveByOwner() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + + vm.prank(owner); + vm.expectEmit(true, false, false, true); + emit ProviderRegistered(reputationProvider, 0.01 ether); + providerRegistry.approveReputationRegistration(reputationProvider); + + assertTrue(providerRegistry.providerRegistered(reputationProvider)); + assertEq(providerRegistry.getProviderStake(reputationProvider), 0.01 ether); + assertEq(providerRegistry.reputationProviderApprover(reputationProvider), owner); + assertEq(providerRegistry.pendingReputationStake(reputationProvider), 0); + // Owner should not have lock count incremented + assertEq(providerRegistry.approverLockCount(owner), 0); + } + + function test_ApproveByStandardProvider() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + + assertTrue(providerRegistry.providerRegistered(reputationProvider)); + assertEq(providerRegistry.reputationProviderApprover(reputationProvider), standardProvider); + assertEq(providerRegistry.approverLockCount(standardProvider), 1); + } + + function test_RevertWhen_ApproveByUnregisteredProvider() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + + vm.prank(randomUser); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.ProviderNotRegistered.selector, randomUser + )); + providerRegistry.approveReputationRegistration(reputationProvider); + } + + function test_RevertWhen_ApproveByProviderWithInsufficientStake() public { + // Register a provider, then slash them below minStake + address weakProvider = vm.addr(10); + vm.deal(weakProvider, 100 ether); + vm.prank(weakProvider); + providerRegistry.registerAndStake{value: 5 ether}(); + + // Slash them down + vm.prank(address(preconfManager)); + providerRegistry.slash(4.5 ether, weakProvider, payable(randomUser)); + + // Now they have 0.05 ether stake (< 5 ether minStake) + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + + vm.prank(weakProvider); + vm.expectRevert(); + providerRegistry.approveReputationRegistration(reputationProvider); + } + + function test_RevertWhen_ApproveWithNoPendingRequest() public { + vm.prank(owner); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.NoPendingReputationRequest.selector, reputationProvider + )); + providerRegistry.approveReputationRegistration(reputationProvider); + } + + // =========== isProviderValid =========== + + function test_IsProviderValidForReputationProvider() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(owner); + providerRegistry.approveReputationRegistration(reputationProvider); + + // Should not revert - reputation provider is valid with 0.01 ETH + providerRegistry.isProviderValid(reputationProvider); + } + + function test_AreProvidersValidIncludesReputationProvider() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(owner); + providerRegistry.approveReputationRegistration(reputationProvider); + + // Add a BLS key so areProvidersValid passes the hasBLSKey check + bytes memory blsKey = hex"80000cddeec66a800e00b0ccbb62f12298073603f5209e812abbac7e870482e488dd1bbe533a9d44497ba8b756e1e82b"; + vm.prank(owner); + providerRegistry.overrideAddBLSKey(reputationProvider, blsKey); + + address[] memory providers = new address[](2); + providers[0] = standardProvider; + providers[1] = reputationProvider; + + bool[] memory results = providerRegistry.areProvidersValid(providers); + // standardProvider has no BLS key in this test, so it would be false + // reputationProvider has a BLS key and sufficient reputation stake + assertTrue(results[1], "Reputation provider should be valid"); + } + + // =========== Remove Reputation Provider =========== + + function test_RemoveByApprover() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + + assertEq(providerRegistry.approverLockCount(standardProvider), 1); + + vm.prank(standardProvider); + vm.expectEmit(true, true, false, true); + emit ReputationProviderRemoved(reputationProvider, standardProvider); + providerRegistry.removeReputationProvider(reputationProvider); + + assertEq(providerRegistry.reputationProviderApprover(reputationProvider), address(0)); + assertEq(providerRegistry.approverLockCount(standardProvider), 0); + // Unstake should have been initiated + assertEq(providerRegistry.withdrawalRequests(reputationProvider), block.timestamp); + } + + function test_RemoveByOwnerWhenOwnerApproved() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(owner); + providerRegistry.approveReputationRegistration(reputationProvider); + + vm.prank(owner); + providerRegistry.removeReputationProvider(reputationProvider); + + assertEq(providerRegistry.reputationProviderApprover(reputationProvider), address(0)); + } + + function test_RevertWhen_OwnerRemovesProviderApprovedByOther() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + + vm.prank(owner); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.NotApprover.selector, owner + )); + providerRegistry.removeReputationProvider(reputationProvider); + } + + function test_RevertWhen_RandomUserRemoves() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(owner); + providerRegistry.approveReputationRegistration(reputationProvider); + + vm.prank(randomUser); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.NotApprover.selector, randomUser + )); + providerRegistry.removeReputationProvider(reputationProvider); + } + + function test_RevertWhen_RemoveNonReputationProvider() public { + vm.prank(owner); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.ProviderIsNotReputationProvider.selector, standardProvider + )); + providerRegistry.removeReputationProvider(standardProvider); + } + + function test_RemoveFullySlashedReputationProvider() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(owner); + providerRegistry.approveReputationRegistration(reputationProvider); + + // Slash the reputation provider to 0 + vm.prank(address(preconfManager)); + providerRegistry.slash(0.01 ether, reputationProvider, payable(randomUser)); + + assertEq(providerRegistry.getProviderStake(reputationProvider), 0); + + vm.prank(owner); + providerRegistry.removeReputationProvider(reputationProvider); + + // Should be fully deregistered since stake is 0 + assertFalse(providerRegistry.providerRegistered(reputationProvider)); + assertEq(providerRegistry.reputationProviderApprover(reputationProvider), address(0)); + } + + // =========== Approver Withdrawal Lock =========== + + function test_ApproverCannotUnstakeWithActiveReputationProviders() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + + vm.prank(standardProvider); + vm.expectRevert(abi.encodeWithSelector( + IProviderRegistry.ApproverHasActiveReputationProviders.selector, + standardProvider, + 1 + )); + providerRegistry.unstake(); + } + + function test_ApproverCanUnstakeAfterRemovingReputationProvider() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + + // Remove the reputation provider first + vm.prank(standardProvider); + providerRegistry.removeReputationProvider(reputationProvider); + + // Now unstake should work + vm.prank(standardProvider); + providerRegistry.unstake(); + assertEq(providerRegistry.withdrawalRequests(standardProvider), block.timestamp); + } + + function test_OwnerNotLockedWhenApprovingReputationProviders() public { + // Owner should never be locked + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(owner); + providerRegistry.approveReputationRegistration(reputationProvider); + + assertEq(providerRegistry.approverLockCount(owner), 0); + } + + function test_ApproverLockCountWithMultipleReputationProviders() public { + address repProvider2 = vm.addr(20); + vm.deal(repProvider2, 100 ether); + + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(repProvider2); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(repProvider2); + + assertEq(providerRegistry.approverLockCount(standardProvider), 2); + + // Can't unstake with 2 active + vm.prank(standardProvider); + vm.expectRevert(); + providerRegistry.unstake(); + + // Remove one + vm.prank(standardProvider); + providerRegistry.removeReputationProvider(reputationProvider); + assertEq(providerRegistry.approverLockCount(standardProvider), 1); + + // Still can't unstake with 1 active + vm.prank(standardProvider); + vm.expectRevert(); + providerRegistry.unstake(); + + // Remove the other + vm.prank(standardProvider); + providerRegistry.removeReputationProvider(repProvider2); + assertEq(providerRegistry.approverLockCount(standardProvider), 0); + + // Now can unstake + vm.prank(standardProvider); + providerRegistry.unstake(); + } + + // =========== Auto-Conversion =========== + + function test_AutoConvertWhenStakeReachesMinStake() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + + assertEq(providerRegistry.approverLockCount(standardProvider), 1); + + // Stake up to minStake + vm.prank(reputationProvider); + providerRegistry.stake{value: 4.99 ether}(); + + // Should be auto-converted - reputation status cleared, approver lock released + assertEq(providerRegistry.reputationProviderApprover(reputationProvider), address(0)); + assertEq(providerRegistry.approverLockCount(standardProvider), 0); + assertTrue(providerRegistry.providerRegistered(reputationProvider)); + assertEq(providerRegistry.getProviderStake(reputationProvider), 5 ether); + + // isProviderValid should still pass (now checked against minStake) + providerRegistry.isProviderValid(reputationProvider); + } + + function test_AutoConvertDoesNotTriggerBelowMinStake() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + + // Stake but not enough to reach minStake + vm.prank(reputationProvider); + providerRegistry.stake{value: 1 ether}(); + + // Should still be a reputation provider + assertEq(providerRegistry.reputationProviderApprover(reputationProvider), standardProvider); + assertEq(providerRegistry.approverLockCount(standardProvider), 1); + } + + function test_AutoConvertReleasesOwnerApproverLock() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(owner); + providerRegistry.approveReputationRegistration(reputationProvider); + + // Owner lock count should be 0 (owner is exempt) + assertEq(providerRegistry.approverLockCount(owner), 0); + + // Stake up to minStake + vm.prank(reputationProvider); + providerRegistry.stake{value: 4.99 ether}(); + + // Should be auto-converted + assertEq(providerRegistry.reputationProviderApprover(reputationProvider), address(0)); + // Owner lock count should still be 0 + assertEq(providerRegistry.approverLockCount(owner), 0); + } + + // =========== Withdraw Clears Reputation Status =========== + + function test_WithdrawClearsReputationStatus() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + + // Reputation provider voluntarily unstakes + vm.prank(reputationProvider); + providerRegistry.unstake(); + + vm.warp(block.timestamp + 24 hours); + + vm.prank(reputationProvider); + providerRegistry.withdraw(); + + assertFalse(providerRegistry.providerRegistered(reputationProvider)); + assertEq(providerRegistry.reputationProviderApprover(reputationProvider), address(0)); + assertEq(providerRegistry.approverLockCount(standardProvider), 0); + assertEq(providerRegistry.getProviderStake(reputationProvider), 0); + } + + function test_ReRegistrationRequiresNewApproval() public { + // Full lifecycle: request -> approve -> unstake -> withdraw -> request again + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(owner); + providerRegistry.approveReputationRegistration(reputationProvider); + + vm.prank(reputationProvider); + providerRegistry.unstake(); + vm.warp(block.timestamp + 24 hours); + vm.prank(reputationProvider); + providerRegistry.withdraw(); + + // Should be able to request again + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + assertEq(providerRegistry.pendingReputationStake(reputationProvider), 0.01 ether); + } + + // =========== Reputation Provider Cannot Approve Others =========== + + function test_ReputationProviderCannotApproveOthers() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(owner); + providerRegistry.approveReputationRegistration(reputationProvider); + + // Another provider requests + address repProvider2 = vm.addr(20); + vm.deal(repProvider2, 100 ether); + vm.prank(repProvider2); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + + // Reputation provider tries to approve — should fail because their stake < minStake + vm.prank(reputationProvider); + vm.expectRevert(); + providerRegistry.approveReputationRegistration(repProvider2); + } + + // =========== Slash Reputation Provider =========== + + function test_SlashReputationProvider() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(owner); + providerRegistry.approveReputationRegistration(reputationProvider); + + address bidder = vm.addr(30); + uint256 bidderBefore = bidder.balance; + + vm.prank(address(preconfManager)); + providerRegistry.slash(0.005 ether, reputationProvider, payable(bidder)); + + assertEq(bidder.balance - bidderBefore, 0.005 ether); + // Stake reduced (minus slash + penalty fee) + assertTrue(providerRegistry.getProviderStake(reputationProvider) < 0.01 ether); + } + + // =========== Edge Cases =========== + + function test_DelegateStakeTriggersAutoConversion() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + + // Someone else stakes on behalf of the reputation provider + vm.prank(randomUser); + providerRegistry.delegateStake{value: 4.99 ether}(reputationProvider); + + // Should be auto-converted + assertEq(providerRegistry.reputationProviderApprover(reputationProvider), address(0)); + assertEq(providerRegistry.approverLockCount(standardProvider), 0); + assertEq(providerRegistry.getProviderStake(reputationProvider), 5 ether); + } + + function test_RemoveAlreadyUnstakingReputationProvider() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.01 ether}(); + vm.prank(standardProvider); + providerRegistry.approveReputationRegistration(reputationProvider); + + // Reputation provider starts unstaking themselves + vm.prank(reputationProvider); + providerRegistry.unstake(); + + // Approver also removes them — should not overwrite the withdrawal request + uint256 originalTimestamp = providerRegistry.withdrawalRequests(reputationProvider); + vm.prank(standardProvider); + providerRegistry.removeReputationProvider(reputationProvider); + + // Withdrawal request should remain the same (not overwritten) + assertEq(providerRegistry.withdrawalRequests(reputationProvider), originalTimestamp); + assertEq(providerRegistry.approverLockCount(standardProvider), 0); + } + + function test_RequestWithExactReputationMinStake() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: reputationMinStake}(); + assertEq(providerRegistry.pendingReputationStake(reputationProvider), reputationMinStake); + } + + function test_RequestWithMoreThanReputationMinStake() public { + vm.prank(reputationProvider); + providerRegistry.requestReputationRegistration{value: 0.5 ether}(); + assertEq(providerRegistry.pendingReputationStake(reputationProvider), 0.5 ether); + } +} diff --git a/oracle/pkg/updater/position_constraint_test.go b/oracle/pkg/updater/position_constraint_test.go new file mode 100644 index 000000000..e2bbebcff --- /dev/null +++ b/oracle/pkg/updater/position_constraint_test.go @@ -0,0 +1,198 @@ +package updater + +import ( + "fmt" + "testing" + + bidderapiv1 "github.com/primev/mev-commit/p2p/gen/go/bidderapi/v1" +) + +func buildTxnMap(size int) map[string]TxMetadata { + txns := make(map[string]TxMetadata, size) + for i := 0; i < size; i++ { + txns[fmt.Sprintf("tx%d", i)] = TxMetadata{ + PosInBlock: i, + Succeeded: true, + GasUsed: 100000, + TotalGas: uint64(size) * 100000, + } + } + return txns +} + +func TestCheckPositionConstraint_AbsoluteBottom(t *testing.T) { + t.Parallel() + + txns := buildTxnMap(10) + + tests := []struct { + name string + value int32 + pos int + expected bool + }{ + {"value=0, last position (9)", 0, 9, true}, + {"value=0, second to last (8)", 0, 8, false}, + {"value=0, first position (0)", 0, 0, false}, + {"value=1, position 8", 1, 8, true}, + {"value=1, position 9", 1, 9, true}, + {"value=1, position 7", 1, 7, false}, + {"value=2, position 7", 2, 7, true}, + {"value=2, position 6", 2, 6, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + constraint := &bidderapiv1.PositionConstraint{ + Anchor: bidderapiv1.PositionConstraint_ANCHOR_BOTTOM, + Basis: bidderapiv1.PositionConstraint_BASIS_ABSOLUTE, + Value: tt.value, + } + txMeta := txns[fmt.Sprintf("tx%d", tt.pos)] + result := checkPositionConstraintSatisfied(constraint, txMeta, txns) + if result != tt.expected { + t.Errorf("pos=%d, value=%d: got %v, want %v", tt.pos, tt.value, result, tt.expected) + } + }) + } +} + +func TestCheckPositionConstraint_AbsoluteTop(t *testing.T) { + t.Parallel() + + txns := buildTxnMap(10) + + tests := []struct { + name string + value int32 + pos int + expected bool + }{ + {"value=0, first position (0)", 0, 0, true}, + {"value=0, second position (1)", 0, 1, false}, + {"value=1, position 0", 1, 0, true}, + {"value=1, position 1", 1, 1, true}, + {"value=1, position 2", 1, 2, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + constraint := &bidderapiv1.PositionConstraint{ + Anchor: bidderapiv1.PositionConstraint_ANCHOR_TOP, + Basis: bidderapiv1.PositionConstraint_BASIS_ABSOLUTE, + Value: tt.value, + } + txMeta := txns[fmt.Sprintf("tx%d", tt.pos)] + result := checkPositionConstraintSatisfied(constraint, txMeta, txns) + if result != tt.expected { + t.Errorf("pos=%d, value=%d: got %v, want %v", tt.pos, tt.value, result, tt.expected) + } + }) + } +} + +func TestCheckPositionConstraint_PercentileBottom(t *testing.T) { + t.Parallel() + + txns := buildTxnMap(10) + + tests := []struct { + name string + value int32 + pos int + expected bool + }{ + {"value=0, last position (9)", 0, 9, true}, + {"value=0, position 8", 0, 8, false}, + {"value=10, position 8", 10, 8, true}, + {"value=10, position 9", 10, 9, true}, + {"value=10, position 7", 10, 7, false}, + {"value=20, position 7", 20, 7, true}, + {"value=20, position 6", 20, 6, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + constraint := &bidderapiv1.PositionConstraint{ + Anchor: bidderapiv1.PositionConstraint_ANCHOR_BOTTOM, + Basis: bidderapiv1.PositionConstraint_BASIS_PERCENTILE, + Value: tt.value, + } + txMeta := txns[fmt.Sprintf("tx%d", tt.pos)] + result := checkPositionConstraintSatisfied(constraint, txMeta, txns) + if result != tt.expected { + t.Errorf("pos=%d, value=%d: got %v, want %v", tt.pos, tt.value, result, tt.expected) + } + }) + } +} + +func TestCheckPositionConstraint_PercentileTop(t *testing.T) { + t.Parallel() + + txns := buildTxnMap(10) + + tests := []struct { + name string + value int32 + pos int + expected bool + }{ + {"value=0, first position (0)", 0, 0, true}, + {"value=0, second position (1)", 0, 1, false}, + {"value=10, position 1", 10, 1, true}, + {"value=10, position 0", 10, 0, true}, + {"value=10, position 2", 10, 2, false}, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + constraint := &bidderapiv1.PositionConstraint{ + Anchor: bidderapiv1.PositionConstraint_ANCHOR_TOP, + Basis: bidderapiv1.PositionConstraint_BASIS_PERCENTILE, + Value: tt.value, + } + txMeta := txns[fmt.Sprintf("tx%d", tt.pos)] + result := checkPositionConstraintSatisfied(constraint, txMeta, txns) + if result != tt.expected { + t.Errorf("pos=%d, value=%d: got %v, want %v", tt.pos, tt.value, result, tt.expected) + } + }) + } +} + +func TestCheckPositionConstraint_Symmetry(t *testing.T) { + t.Parallel() + + txns := buildTxnMap(10) + + // ANCHOR_TOP value=0 covers 1 position (pos 0) + // ANCHOR_BOTTOM value=0 should also cover 1 position (pos 9) + topCount := 0 + bottomCount := 0 + for i := 0; i < 10; i++ { + txMeta := txns[fmt.Sprintf("tx%d", i)] + topConstraint := &bidderapiv1.PositionConstraint{ + Anchor: bidderapiv1.PositionConstraint_ANCHOR_TOP, + Basis: bidderapiv1.PositionConstraint_BASIS_ABSOLUTE, + Value: 0, + } + if checkPositionConstraintSatisfied(topConstraint, txMeta, txns) { + topCount++ + } + bottomConstraint := &bidderapiv1.PositionConstraint{ + Anchor: bidderapiv1.PositionConstraint_ANCHOR_BOTTOM, + Basis: bidderapiv1.PositionConstraint_BASIS_ABSOLUTE, + Value: 0, + } + if checkPositionConstraintSatisfied(bottomConstraint, txMeta, txns) { + bottomCount++ + } + } + if topCount != 1 { + t.Errorf("ANCHOR_TOP value=0 matched %d positions, want 1", topCount) + } + if bottomCount != 1 { + t.Errorf("ANCHOR_BOTTOM value=0 matched %d positions, want 1", bottomCount) + } +} diff --git a/oracle/pkg/updater/updater.go b/oracle/pkg/updater/updater.go index 33070d2be..17132406d 100644 --- a/oracle/pkg/updater/updater.go +++ b/oracle/pkg/updater/updater.go @@ -197,7 +197,7 @@ func checkPositionConstraintSatisfied( return true } case bidderapiv1.PositionConstraint_ANCHOR_BOTTOM: - if txnDetails.PosInBlock >= len(txns)-int(c.Value) { + if txnDetails.PosInBlock >= len(txns)-1-int(c.Value) { return true } } @@ -208,7 +208,7 @@ func checkPositionConstraintSatisfied( return true } case bidderapiv1.PositionConstraint_ANCHOR_BOTTOM: - if txnDetails.PosInBlock >= (len(txns)*(100-int(c.Value)))/100 { + if txnDetails.PosInBlock >= ((len(txns)-1)*(100-int(c.Value)))/100 { return true } } diff --git a/oracle/pkg/updater/updater_test.go b/oracle/pkg/updater/updater_test.go index e161b35f9..91b63c605 100644 --- a/oracle/pkg/updater/updater_test.go +++ b/oracle/pkg/updater/updater_test.go @@ -1474,7 +1474,7 @@ func TestBidOptions(t *testing.T) { PositionConstraint: &bidderapiv1.PositionConstraint{ Anchor: bidderapiv1.PositionConstraint_ANCHOR_BOTTOM, Basis: bidderapiv1.PositionConstraint_BASIS_ABSOLUTE, - Value: 2, + Value: 1, }, }, }, diff --git a/tools/preconf-rpc/backrunner/backrunner.go b/tools/preconf-rpc/backrunner/backrunner.go index ff7db529f..ee4d52d9b 100644 --- a/tools/preconf-rpc/backrunner/backrunner.go +++ b/tools/preconf-rpc/backrunner/backrunner.go @@ -25,6 +25,7 @@ var builders = map[common.Address]string{ common.HexToAddress("0x2445e5e28890De3e93F39fCA817639c470F4d3b9"): "iobuilder", common.HexToAddress("0xB3998135372F1eE16Cb510af70ed212b5155Af62"): "titan", common.HexToAddress("0x570e531fB805B5eEbD5F29Eaa2766fBeB4977ddE"): "quasar", + common.HexToAddress("0x9934Db4Dc89470c5C5921763764d7541629E3A46"): "eureka", } type Store interface { From 20dc6a20ddce0ab41a227d1be555e6039ddfde86 Mon Sep 17 00:00:00 2001 From: owen-eth Date: Mon, 23 Mar 2026 03:20:14 -0400 Subject: [PATCH 2/4] updated go bindings and abis --- contracts-abi/abi/PreconfManager.abi | 13 + contracts-abi/abi/ProviderRegistry.abi | 304 ++++++ .../clients/PreconfManager/PreconfManager.go | 33 +- .../ProviderRegistry/ProviderRegistry.go | 971 +++++++++++++++++- 4 files changed, 1319 insertions(+), 2 deletions(-) diff --git a/contracts-abi/abi/PreconfManager.abi b/contracts-abi/abi/PreconfManager.abi index 3f8aa7ebb..01d3d99d5 100644 --- a/contracts-abi/abi/PreconfManager.abi +++ b/contracts-abi/abi/PreconfManager.abi @@ -51,6 +51,19 @@ ], "stateMutability": "view" }, + { + "type": "function", + "name": "MAX_SLASH_BID_RATIO", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, { "type": "function", "name": "UPGRADE_INTERFACE_VERSION", diff --git a/contracts-abi/abi/ProviderRegistry.abi b/contracts-abi/abi/ProviderRegistry.abi index 19ea06bb8..8010b130d 100644 --- a/contracts-abi/abi/ProviderRegistry.abi +++ b/contracts-abi/abi/ProviderRegistry.abi @@ -76,6 +76,38 @@ "outputs": [], "stateMutability": "nonpayable" }, + { + "type": "function", + "name": "approveReputationRegistration", + "inputs": [ + { + "name": "provider", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, + { + "type": "function", + "name": "approverLockCount", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, { "type": "function", "name": "areProvidersValid", @@ -133,6 +165,13 @@ ], "stateMutability": "view" }, + { + "type": "function", + "name": "cancelReputationRegistration", + "inputs": [], + "outputs": [], + "stateMutability": "nonpayable" + }, { "type": "function", "name": "delegateRegisterAndStake", @@ -447,6 +486,25 @@ ], "stateMutability": "view" }, + { + "type": "function", + "name": "pendingReputationStake", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, { "type": "function", "name": "preconfManager", @@ -518,6 +576,19 @@ "outputs": [], "stateMutability": "payable" }, + { + "type": "function", + "name": "removeReputationProvider", + "inputs": [ + { + "name": "provider", + "type": "address", + "internalType": "address" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, { "type": "function", "name": "renounceOwnership", @@ -525,6 +596,45 @@ "outputs": [], "stateMutability": "nonpayable" }, + { + "type": "function", + "name": "reputationMinStake", + "inputs": [], + "outputs": [ + { + "name": "", + "type": "uint256", + "internalType": "uint256" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "reputationProviderApprover", + "inputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "outputs": [ + { + "name": "", + "type": "address", + "internalType": "address" + } + ], + "stateMutability": "view" + }, + { + "type": "function", + "name": "requestReputationRegistration", + "inputs": [], + "outputs": [], + "stateMutability": "payable" + }, { "type": "function", "name": "setFeePayoutPeriod", @@ -590,6 +700,19 @@ "outputs": [], "stateMutability": "nonpayable" }, + { + "type": "function", + "name": "setReputationMinStake", + "inputs": [ + { + "name": "_reputationMinStake", + "type": "uint256", + "internalType": "uint256" + } + ], + "outputs": [], + "stateMutability": "nonpayable" + }, { "type": "function", "name": "setWithdrawalDelay", @@ -1046,6 +1169,95 @@ ], "anonymous": false }, + { + "type": "event", + "name": "ReputationMinStakeUpdated", + "inputs": [ + { + "name": "newMinStake", + "type": "uint256", + "indexed": true, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ReputationProviderApproved", + "inputs": [ + { + "name": "provider", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "approver", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ReputationProviderRemoved", + "inputs": [ + { + "name": "provider", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "approver", + "type": "address", + "indexed": true, + "internalType": "address" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ReputationRegistrationCancelled", + "inputs": [ + { + "name": "provider", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "returnedAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, + { + "type": "event", + "name": "ReputationRegistrationRequested", + "inputs": [ + { + "name": "provider", + "type": "address", + "indexed": true, + "internalType": "address" + }, + { + "name": "stakedAmount", + "type": "uint256", + "indexed": false, + "internalType": "uint256" + } + ], + "anonymous": false + }, { "type": "event", "name": "TransferToBidderFailed", @@ -1153,6 +1365,22 @@ } ] }, + { + "type": "error", + "name": "ApproverHasActiveReputationProviders", + "inputs": [ + { + "name": "approver", + "type": "address", + "internalType": "address" + }, + { + "name": "count", + "type": "uint256", + "internalType": "uint256" + } + ] + }, { "type": "error", "name": "AtLeastOneBLSKeyRequired", @@ -1269,6 +1497,22 @@ "name": "FeeRecipientIsZero", "inputs": [] }, + { + "type": "error", + "name": "InsufficientReputationStake", + "inputs": [ + { + "name": "stake", + "type": "uint256", + "internalType": "uint256" + }, + { + "name": "minStake", + "type": "uint256", + "internalType": "uint256" + } + ] + }, { "type": "error", "name": "InsufficientStake", @@ -1316,6 +1560,17 @@ "name": "InvalidReceive", "inputs": [] }, + { + "type": "error", + "name": "NoPendingReputationRequest", + "inputs": [ + { + "name": "provider", + "type": "address", + "internalType": "address" + } + ] + }, { "type": "error", "name": "NoStakeToWithdraw", @@ -1338,6 +1593,33 @@ } ] }, + { + "type": "error", + "name": "NotApprover", + "inputs": [ + { + "name": "sender", + "type": "address", + "internalType": "address" + } + ] + }, + { + "type": "error", + "name": "NotApproverOrOwner", + "inputs": [ + { + "name": "sender", + "type": "address", + "internalType": "address" + }, + { + "name": "approver", + "type": "address", + "internalType": "address" + } + ] + }, { "type": "error", "name": "NotInitializing", @@ -1386,6 +1668,17 @@ "name": "PayoutPeriodMustBePositive", "inputs": [] }, + { + "type": "error", + "name": "PendingReputationRequestExists", + "inputs": [ + { + "name": "provider", + "type": "address", + "internalType": "address" + } + ] + }, { "type": "error", "name": "PendingWithdrawalRequest", @@ -1429,6 +1722,17 @@ } ] }, + { + "type": "error", + "name": "ProviderIsNotReputationProvider", + "inputs": [ + { + "name": "provider", + "type": "address", + "internalType": "address" + } + ] + }, { "type": "error", "name": "ProviderNotRegistered", diff --git a/contracts-abi/clients/PreconfManager/PreconfManager.go b/contracts-abi/clients/PreconfManager/PreconfManager.go index 238b240ff..c9a29aeff 100644 --- a/contracts-abi/clients/PreconfManager/PreconfManager.go +++ b/contracts-abi/clients/PreconfManager/PreconfManager.go @@ -88,7 +88,7 @@ type IPreconfManagerUnopenedCommitment struct { // PreconfmanagerMetaData contains all meta data concerning the Preconfmanager contract. var PreconfmanagerMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"fallback\",\"stateMutability\":\"payable\"},{\"type\":\"receive\",\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"EIP712_BID_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"EIP712_COMMITMENT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"HEXCHARS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"UPGRADE_INTERFACE_VERSION\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"acceptOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"bidderRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBidderRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blockTracker\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBlockTracker\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"commitmentDispatchWindow\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"commitmentsCount\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"domainSeparatorBid\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"domainSeparatorPreconf\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getBidHash\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.OpenCommitmentParams\",\"components\":[{\"name\":\"unopenedCommitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"zkProof\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCommitment\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.OpenedCommitment\",\"components\":[{\"name\":\"bidder\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"isSettled\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOpenedCommitmentIndex\",\"inputs\":[{\"name\":\"commitment\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.OpenedCommitment\",\"components\":[{\"name\":\"bidder\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"isSettled\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"getPreConfHash\",\"inputs\":[{\"name\":\"_bidHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"_bidSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"_zkProof\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTxnHashFromCommitment\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getUnopenedCommitment\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.UnopenedCommitment\",\"components\":[{\"name\":\"isOpened\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getUnopenedCommitmentIndex\",\"inputs\":[{\"name\":\"commitment\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.UnopenedCommitment\",\"components\":[{\"name\":\"isOpened\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_providerRegistry\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_bidderRegistry\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_oracleContract\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_blockTracker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_commitmentDispatchWindow\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initiateReward\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"residualBidPercentAfterDecay\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initiateSlash\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"openCommitment\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.OpenCommitmentParams\",\"components\":[{\"name\":\"unopenedCommitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"zkProof\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"openedCommitments\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"bidder\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"isSettled\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"oracleContract\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingOwner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"processedTxnHashes\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"providerRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIProviderRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"proxiableUUID\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"storeUnopenedCommitment\",\"inputs\":[{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unopenedCommitments\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"isOpened\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateBidderRegistry\",\"inputs\":[{\"name\":\"newBidderRegistry\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateBlockTracker\",\"inputs\":[{\"name\":\"newBlockTracker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateCommitmentDispatchWindow\",\"inputs\":[{\"name\":\"newDispatchWindow\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOracleContract\",\"inputs\":[{\"name\":\"newOracleContract\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateProviderRegistry\",\"inputs\":[{\"name\":\"newProviderRegistry\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"upgradeToAndCall\",\"inputs\":[{\"name\":\"newImplementation\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"verifyBid\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.OpenCommitmentParams\",\"components\":[{\"name\":\"unopenedCommitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"zkProof\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"messageDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"recoveredAddress\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"verifyPreConfCommitment\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.CommitmentParams\",\"components\":[{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"bidHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"bidSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"zkProof\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"outputs\":[{\"name\":\"preConfHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"committerAddress\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"zkContextHash\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"BidderRegistryUpdated\",\"inputs\":[{\"name\":\"newBidderRegistry\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BlockTrackerUpdated\",\"inputs\":[{\"name\":\"newBlockTracker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"CommitmentDispatchWindowUpdated\",\"inputs\":[{\"name\":\"newDispatchWindow\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OpenedCommitmentStored\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"bidder\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"committer\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"txnHash\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OracleContractUpdated\",\"inputs\":[{\"name\":\"newOracleContract\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferStarted\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ProviderRegistryUpdated\",\"inputs\":[{\"name\":\"newProviderRegistry\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SignatureVerified\",\"inputs\":[{\"name\":\"signer\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"txnHash\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"UnopenedCommitmentStored\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"committer\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Upgraded\",\"inputs\":[{\"name\":\"implementation\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AddressEmptyCode\",\"inputs\":[{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"BN128AddFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BN128MulFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CommitmentAlreadyOpened\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"CommitmentAlreadySettled\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"ERC1967InvalidImplementation\",\"inputs\":[{\"name\":\"implementation\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ERC1967NonPayable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EnforcedPause\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ExpectedPause\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FailedInnerCall\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCommitmentDigest\",\"inputs\":[{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"computedDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"InvalidDecayTime\",\"inputs\":[{\"name\":\"startTime\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"endTime\",\"type\":\"uint64\",\"internalType\":\"uint64\"}]},{\"type\":\"error\",\"name\":\"InvalidDispatchTimestamp\",\"inputs\":[{\"name\":\"minTime\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"}]},{\"type\":\"error\",\"name\":\"InvalidFallback\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidInitialization\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidReceive\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotInitializing\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OwnableInvalidOwner\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"OwnableUnauthorizedAccount\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ProviderZKProofInvalid\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"SenderIsNotCommitter\",\"inputs\":[{\"name\":\"expected\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"actual\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"SenderIsNotOracleContract\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"oracleContract\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"TxnHashAlreadyProcessed\",\"inputs\":[{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidderAddress\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"UUPSUnauthorizedCallContext\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UUPSUnsupportedProxiableUUID\",\"inputs\":[{\"name\":\"slot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"UnauthorizedOpenCommitment\",\"inputs\":[{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bidder\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"UnopenedCommitmentAlreadyExists\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"WinnerIsNotCommitter\",\"inputs\":[{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"winner\",\"type\":\"address\",\"internalType\":\"address\"}]}]", + ABI: "[{\"type\":\"constructor\",\"inputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"fallback\",\"stateMutability\":\"payable\"},{\"type\":\"receive\",\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"EIP712_BID_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"EIP712_COMMITMENT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"HEXCHARS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"MAX_SLASH_BID_RATIO\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"UPGRADE_INTERFACE_VERSION\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"acceptOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"bidderRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBidderRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blockTracker\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBlockTracker\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"commitmentDispatchWindow\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"commitmentsCount\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"domainSeparatorBid\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"domainSeparatorPreconf\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getBidHash\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.OpenCommitmentParams\",\"components\":[{\"name\":\"unopenedCommitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"zkProof\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCommitment\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.OpenedCommitment\",\"components\":[{\"name\":\"bidder\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"isSettled\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOpenedCommitmentIndex\",\"inputs\":[{\"name\":\"commitment\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.OpenedCommitment\",\"components\":[{\"name\":\"bidder\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"isSettled\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"getPreConfHash\",\"inputs\":[{\"name\":\"_bidHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"_bidSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"_zkProof\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getTxnHashFromCommitment\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getUnopenedCommitment\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.UnopenedCommitment\",\"components\":[{\"name\":\"isOpened\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getUnopenedCommitmentIndex\",\"inputs\":[{\"name\":\"commitment\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.UnopenedCommitment\",\"components\":[{\"name\":\"isOpened\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_providerRegistry\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_bidderRegistry\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_oracleContract\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_blockTracker\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_commitmentDispatchWindow\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initiateReward\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"residualBidPercentAfterDecay\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"initiateSlash\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"openCommitment\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.OpenCommitmentParams\",\"components\":[{\"name\":\"unopenedCommitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"zkProof\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"openedCommitments\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"bidder\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"isSettled\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"oracleContract\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingOwner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"processedTxnHashes\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"providerRegistry\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIProviderRegistry\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"proxiableUUID\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"storeUnopenedCommitment\",\"inputs\":[{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unopenedCommitments\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"isOpened\",\"type\":\"bool\",\"internalType\":\"bool\"},{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateBidderRegistry\",\"inputs\":[{\"name\":\"newBidderRegistry\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateBlockTracker\",\"inputs\":[{\"name\":\"newBlockTracker\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateCommitmentDispatchWindow\",\"inputs\":[{\"name\":\"newDispatchWindow\",\"type\":\"uint64\",\"internalType\":\"uint64\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOracleContract\",\"inputs\":[{\"name\":\"newOracleContract\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateProviderRegistry\",\"inputs\":[{\"name\":\"newProviderRegistry\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"upgradeToAndCall\",\"inputs\":[{\"name\":\"newImplementation\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"verifyBid\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.OpenCommitmentParams\",\"components\":[{\"name\":\"unopenedCommitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"zkProof\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"messageDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"recoveredAddress\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"verifyPreConfCommitment\",\"inputs\":[{\"name\":\"params\",\"type\":\"tuple\",\"internalType\":\"structIPreconfManager.CommitmentParams\",\"components\":[{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"bidHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"bidSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"zkProof\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"outputs\":[{\"name\":\"preConfHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"committerAddress\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"zkContextHash\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"BidderRegistryUpdated\",\"inputs\":[{\"name\":\"newBidderRegistry\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BlockTrackerUpdated\",\"inputs\":[{\"name\":\"newBlockTracker\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"CommitmentDispatchWindowUpdated\",\"inputs\":[{\"name\":\"newDispatchWindow\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OpenedCommitmentStored\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"bidder\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"committer\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"slashAmt\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"decayStartTimeStamp\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"decayEndTimeStamp\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"txnHash\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"},{\"name\":\"bidOptions\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OracleContractUpdated\",\"inputs\":[{\"name\":\"newOracleContract\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferStarted\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ProviderRegistryUpdated\",\"inputs\":[{\"name\":\"newProviderRegistry\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"SignatureVerified\",\"inputs\":[{\"name\":\"signer\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"txnHash\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"},{\"name\":\"revertingTxHashes\",\"type\":\"string\",\"indexed\":false,\"internalType\":\"string\"},{\"name\":\"bidAmt\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"},{\"name\":\"blockNumber\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"UnopenedCommitmentStored\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"},{\"name\":\"committer\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"indexed\":false,\"internalType\":\"bytes32\"},{\"name\":\"commitmentSignature\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Upgraded\",\"inputs\":[{\"name\":\"implementation\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AddressEmptyCode\",\"inputs\":[{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"BN128AddFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BN128MulFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CommitmentAlreadyOpened\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"CommitmentAlreadySettled\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"ERC1967InvalidImplementation\",\"inputs\":[{\"name\":\"implementation\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ERC1967NonPayable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EnforcedPause\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ExpectedPause\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FailedInnerCall\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCommitmentDigest\",\"inputs\":[{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"computedDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"InvalidDecayTime\",\"inputs\":[{\"name\":\"startTime\",\"type\":\"uint64\",\"internalType\":\"uint64\"},{\"name\":\"endTime\",\"type\":\"uint64\",\"internalType\":\"uint64\"}]},{\"type\":\"error\",\"name\":\"InvalidDispatchTimestamp\",\"inputs\":[{\"name\":\"minTime\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"dispatchTimestamp\",\"type\":\"uint64\",\"internalType\":\"uint64\"}]},{\"type\":\"error\",\"name\":\"InvalidFallback\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidInitialization\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidReceive\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotInitializing\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OwnableInvalidOwner\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"OwnableUnauthorizedAccount\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ProviderZKProofInvalid\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"commitmentDigest\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"SenderIsNotCommitter\",\"inputs\":[{\"name\":\"expected\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"actual\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"SenderIsNotOracleContract\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"oracleContract\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"TxnHashAlreadyProcessed\",\"inputs\":[{\"name\":\"txnHash\",\"type\":\"string\",\"internalType\":\"string\"},{\"name\":\"bidderAddress\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"UUPSUnauthorizedCallContext\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UUPSUnsupportedProxiableUUID\",\"inputs\":[{\"name\":\"slot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"UnauthorizedOpenCommitment\",\"inputs\":[{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bidder\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"UnopenedCommitmentAlreadyExists\",\"inputs\":[{\"name\":\"commitmentIndex\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"WinnerIsNotCommitter\",\"inputs\":[{\"name\":\"committer\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"winner\",\"type\":\"address\",\"internalType\":\"address\"}]}]", } // PreconfmanagerABI is the input ABI used to generate the binding from. @@ -330,6 +330,37 @@ func (_Preconfmanager *PreconfmanagerCallerSession) HEXCHARS() ([]byte, error) { return _Preconfmanager.Contract.HEXCHARS(&_Preconfmanager.CallOpts) } +// MAXSLASHBIDRATIO is a free data retrieval call binding the contract method 0xa924593a. +// +// Solidity: function MAX_SLASH_BID_RATIO() view returns(uint256) +func (_Preconfmanager *PreconfmanagerCaller) MAXSLASHBIDRATIO(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Preconfmanager.contract.Call(opts, &out, "MAX_SLASH_BID_RATIO") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// MAXSLASHBIDRATIO is a free data retrieval call binding the contract method 0xa924593a. +// +// Solidity: function MAX_SLASH_BID_RATIO() view returns(uint256) +func (_Preconfmanager *PreconfmanagerSession) MAXSLASHBIDRATIO() (*big.Int, error) { + return _Preconfmanager.Contract.MAXSLASHBIDRATIO(&_Preconfmanager.CallOpts) +} + +// MAXSLASHBIDRATIO is a free data retrieval call binding the contract method 0xa924593a. +// +// Solidity: function MAX_SLASH_BID_RATIO() view returns(uint256) +func (_Preconfmanager *PreconfmanagerCallerSession) MAXSLASHBIDRATIO() (*big.Int, error) { + return _Preconfmanager.Contract.MAXSLASHBIDRATIO(&_Preconfmanager.CallOpts) +} + // UPGRADEINTERFACEVERSION is a free data retrieval call binding the contract method 0xad3cb1cc. // // Solidity: function UPGRADE_INTERFACE_VERSION() view returns(string) diff --git a/contracts-abi/clients/ProviderRegistry/ProviderRegistry.go b/contracts-abi/clients/ProviderRegistry/ProviderRegistry.go index 340ae9f82..e0b085d4d 100644 --- a/contracts-abi/clients/ProviderRegistry/ProviderRegistry.go +++ b/contracts-abi/clients/ProviderRegistry/ProviderRegistry.go @@ -31,7 +31,7 @@ var ( // ProviderregistryMetaData contains all meta data concerning the Providerregistry contract. var ProviderregistryMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"fallback\",\"stateMutability\":\"payable\"},{\"type\":\"receive\",\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"ONE_HUNDRED_PERCENT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"PRECISION\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"UPGRADE_INTERFACE_VERSION\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"acceptOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addVerifiedBLSKey\",\"inputs\":[{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"areProvidersValid\",\"inputs\":[{\"name\":\"providers\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"bidderSlashedAmount\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blockBuilderBLSKeyToAddress\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"delegateRegisterAndStake\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"delegateStake\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"eoaToBlsPubkeys\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"feePercent\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAccumulatedPenaltyFee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getBLSKeys\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes[]\",\"internalType\":\"bytes[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getEoaFromBLSKey\",\"inputs\":[{\"name\":\"blsKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getProviderStake\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_minStake\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_penaltyFeeRecipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_feePercent\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_withdrawalDelay\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_penaltyFeePayoutPeriod\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isProviderValid\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"manuallyWithdrawPenaltyFee\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"minStake\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"overrideAddBLSKey\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"overrideRemoveBLSKey\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"penaltyFeeTracker\",\"inputs\":[],\"outputs\":[{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"accumulatedAmount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"lastPayoutTimestamp\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"payoutTimePeriod\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingOwner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"preconfManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"providerRegistered\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"providerStakes\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"proxiableUUID\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerAndStake\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setFeePayoutPeriod\",\"inputs\":[{\"name\":\"_feePayoutPeriod\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setMinStake\",\"inputs\":[{\"name\":\"_minStake\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setNewFeePercent\",\"inputs\":[{\"name\":\"newFeePercent\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setNewPenaltyFeeRecipient\",\"inputs\":[{\"name\":\"newFeeRecipient\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setPreconfManager\",\"inputs\":[{\"name\":\"contractAddress\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setWithdrawalDelay\",\"inputs\":[{\"name\":\"_withdrawalDelay\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slash\",\"inputs\":[{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bidder\",\"type\":\"address\",\"internalType\":\"addresspayable\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stake\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unstake\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"upgradeToAndCall\",\"inputs\":[{\"name\":\"newImplementation\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"verifySignature\",\"inputs\":[{\"name\":\"pubKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"message\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdraw\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSlashedAmount\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawalDelay\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdrawalRequests\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"BLSKeyAdded\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BLSKeyRemoved\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BidderWithdrawSlashedAmount\",\"inputs\":[{\"name\":\"bidder\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FeePayoutPeriodUpdated\",\"inputs\":[{\"name\":\"newFeePayoutPeriod\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FeePercentUpdated\",\"inputs\":[{\"name\":\"newFeePercent\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FeeTransfer\",\"inputs\":[{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"recipient\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FundsDeposited\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FundsSlashed\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"InsufficientFundsToSlash\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"providerStake\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"penaltyFee\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"bidderPortion\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MinStakeUpdated\",\"inputs\":[{\"name\":\"newMinStake\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferStarted\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PenaltyFeeRecipientUpdated\",\"inputs\":[{\"name\":\"newPenaltyFeeRecipient\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PreconfManagerUpdated\",\"inputs\":[{\"name\":\"newPreconfManager\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ProviderRegistered\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"stakedAmount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TransferToBidderFailed\",\"inputs\":[{\"name\":\"bidder\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unstake\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"timestamp\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Upgraded\",\"inputs\":[{\"name\":\"implementation\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Withdraw\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"WithdrawalDelayUpdated\",\"inputs\":[{\"name\":\"newWithdrawalDelay\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AddressEmptyCode\",\"inputs\":[{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"AtLeastOneBLSKeyRequired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BLSKeyAlreadyExists\",\"inputs\":[{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"type\":\"error\",\"name\":\"BLSKeyDoesNotExist\",\"inputs\":[{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"type\":\"error\",\"name\":\"BLSSignatureInvalid\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BidderAmountIsZero\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"BidderWithdrawalTransferFailed\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"DelayNotPassed\",\"inputs\":[{\"name\":\"withdrawalRequestTimestamp\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"withdrawalDelay\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"currentBlockTimestamp\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"ERC1967InvalidImplementation\",\"inputs\":[{\"name\":\"implementation\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ERC1967NonPayable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EnforcedPause\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ExpectedPause\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FailedInnerCall\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FeeRecipientIsZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientStake\",\"inputs\":[{\"name\":\"stake\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"minStake\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"InvalidBLSPublicKeyLength\",\"inputs\":[{\"name\":\"length\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"expectedLength\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"InvalidFallback\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidInitialization\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidReceive\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NoStakeToWithdraw\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"NoUnstakeRequest\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"NotInitializing\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotPreconfContract\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"preconfManager\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"OwnableInvalidOwner\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"OwnableUnauthorizedAccount\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"PayoutPeriodMustBePositive\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"PendingWithdrawalRequest\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"PreconfManagerNotSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProviderAlreadyRegistered\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ProviderCommitmentsPending\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"numPending\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"ProviderNotRegistered\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"PublicKeyLengthInvalid\",\"inputs\":[{\"name\":\"exp\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"got\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"ReentrancyGuardReentrantCall\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureLengthInvalid\",\"inputs\":[{\"name\":\"exp\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"got\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"StakeTransferFailed\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"TransferToRecipientFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UUPSUnauthorizedCallContext\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UUPSUnsupportedProxiableUUID\",\"inputs\":[{\"name\":\"slot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"UnstakeRequestExists\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]}]", + ABI: "[{\"type\":\"constructor\",\"inputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"fallback\",\"stateMutability\":\"payable\"},{\"type\":\"receive\",\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"ONE_HUNDRED_PERCENT\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"PRECISION\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"UPGRADE_INTERFACE_VERSION\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"acceptOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"addVerifiedBLSKey\",\"inputs\":[{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"approveReputationRegistration\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"approverLockCount\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"areProvidersValid\",\"inputs\":[{\"name\":\"providers\",\"type\":\"address[]\",\"internalType\":\"address[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool[]\",\"internalType\":\"bool[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"bidderSlashedAmount\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"blockBuilderBLSKeyToAddress\",\"inputs\":[{\"name\":\"\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"cancelReputationRegistration\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"delegateRegisterAndStake\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"delegateStake\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"eoaToBlsPubkeys\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"feePercent\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getAccumulatedPenaltyFee\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getBLSKeys\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes[]\",\"internalType\":\"bytes[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getEoaFromBLSKey\",\"inputs\":[{\"name\":\"blsKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getProviderStake\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"_minStake\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_penaltyFeeRecipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_feePercent\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_withdrawalDelay\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"_penaltyFeePayoutPeriod\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"isProviderValid\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"manuallyWithdrawPenaltyFee\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"minStake\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"overrideAddBLSKey\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"overrideRemoveBLSKey\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pause\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"paused\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"penaltyFeeTracker\",\"inputs\":[],\"outputs\":[{\"name\":\"recipient\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"accumulatedAmount\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"lastPayoutTimestamp\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"payoutTimePeriod\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingOwner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"pendingReputationStake\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"preconfManager\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"providerRegistered\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"providerStakes\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"proxiableUUID\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"registerAndStake\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"removeReputationProvider\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"reputationMinStake\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"reputationProviderApprover\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"requestReputationRegistration\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"setFeePayoutPeriod\",\"inputs\":[{\"name\":\"_feePayoutPeriod\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setMinStake\",\"inputs\":[{\"name\":\"_minStake\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setNewFeePercent\",\"inputs\":[{\"name\":\"newFeePercent\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setNewPenaltyFeeRecipient\",\"inputs\":[{\"name\":\"newFeeRecipient\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setPreconfManager\",\"inputs\":[{\"name\":\"contractAddress\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setReputationMinStake\",\"inputs\":[{\"name\":\"_reputationMinStake\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setWithdrawalDelay\",\"inputs\":[{\"name\":\"_withdrawalDelay\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"slash\",\"inputs\":[{\"name\":\"slashAmt\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"bidder\",\"type\":\"address\",\"internalType\":\"addresspayable\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"stake\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unpause\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"unstake\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"upgradeToAndCall\",\"inputs\":[{\"name\":\"newImplementation\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"data\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"payable\"},{\"type\":\"function\",\"name\":\"verifySignature\",\"inputs\":[{\"name\":\"pubKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"message\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdraw\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawSlashedAmount\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"withdrawalDelay\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"withdrawalRequests\",\"inputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"BLSKeyAdded\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BLSKeyRemoved\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"indexed\":false,\"internalType\":\"bytes\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"BidderWithdrawSlashedAmount\",\"inputs\":[{\"name\":\"bidder\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FeePayoutPeriodUpdated\",\"inputs\":[{\"name\":\"newFeePayoutPeriod\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FeePercentUpdated\",\"inputs\":[{\"name\":\"newFeePercent\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FeeTransfer\",\"inputs\":[{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"recipient\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FundsDeposited\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"FundsSlashed\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint64\",\"indexed\":false,\"internalType\":\"uint64\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"InsufficientFundsToSlash\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"providerStake\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"penaltyFee\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"},{\"name\":\"bidderPortion\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MinStakeUpdated\",\"inputs\":[{\"name\":\"newMinStake\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferStarted\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OwnershipTransferred\",\"inputs\":[{\"name\":\"previousOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"newOwner\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Paused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PenaltyFeeRecipientUpdated\",\"inputs\":[{\"name\":\"newPenaltyFeeRecipient\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"PreconfManagerUpdated\",\"inputs\":[{\"name\":\"newPreconfManager\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ProviderRegistered\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"stakedAmount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ReputationMinStakeUpdated\",\"inputs\":[{\"name\":\"newMinStake\",\"type\":\"uint256\",\"indexed\":true,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ReputationProviderApproved\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"approver\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ReputationProviderRemoved\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"approver\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ReputationRegistrationCancelled\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"returnedAmount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"ReputationRegistrationRequested\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"stakedAmount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TransferToBidderFailed\",\"inputs\":[{\"name\":\"bidder\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unpaused\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Unstake\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"timestamp\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Upgraded\",\"inputs\":[{\"name\":\"implementation\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Withdraw\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"indexed\":true,\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"WithdrawalDelayUpdated\",\"inputs\":[{\"name\":\"newWithdrawalDelay\",\"type\":\"uint256\",\"indexed\":false,\"internalType\":\"uint256\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"AddressEmptyCode\",\"inputs\":[{\"name\":\"target\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ApproverHasActiveReputationProviders\",\"inputs\":[{\"name\":\"approver\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"count\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"AtLeastOneBLSKeyRequired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BLSKeyAlreadyExists\",\"inputs\":[{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"type\":\"error\",\"name\":\"BLSKeyDoesNotExist\",\"inputs\":[{\"name\":\"blsPublicKey\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"type\":\"error\",\"name\":\"BLSSignatureInvalid\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"BidderAmountIsZero\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"BidderWithdrawalTransferFailed\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"DelayNotPassed\",\"inputs\":[{\"name\":\"withdrawalRequestTimestamp\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"withdrawalDelay\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"currentBlockTimestamp\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"ERC1967InvalidImplementation\",\"inputs\":[{\"name\":\"implementation\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ERC1967NonPayable\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"EnforcedPause\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ExpectedPause\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FailedInnerCall\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"FeeRecipientIsZero\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InsufficientReputationStake\",\"inputs\":[{\"name\":\"stake\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"minStake\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"InsufficientStake\",\"inputs\":[{\"name\":\"stake\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"minStake\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"InvalidBLSPublicKeyLength\",\"inputs\":[{\"name\":\"length\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"expectedLength\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"InvalidFallback\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidInitialization\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidReceive\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NoPendingReputationRequest\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"NoStakeToWithdraw\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"NoUnstakeRequest\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"NotApprover\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"NotApproverOrOwner\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"approver\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"NotInitializing\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"NotPreconfContract\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"preconfManager\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"OwnableInvalidOwner\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"OwnableUnauthorizedAccount\",\"inputs\":[{\"name\":\"account\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"PayoutPeriodMustBePositive\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"PendingReputationRequestExists\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"PendingWithdrawalRequest\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"PreconfManagerNotSet\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ProviderAlreadyRegistered\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ProviderCommitmentsPending\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"numPending\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"ProviderIsNotReputationProvider\",\"inputs\":[{\"name\":\"provider\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"ProviderNotRegistered\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]},{\"type\":\"error\",\"name\":\"PublicKeyLengthInvalid\",\"inputs\":[{\"name\":\"exp\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"got\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"ReentrancyGuardReentrantCall\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureLengthInvalid\",\"inputs\":[{\"name\":\"exp\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"got\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"StakeTransferFailed\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"amount\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"type\":\"error\",\"name\":\"TransferToRecipientFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UUPSUnauthorizedCallContext\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"UUPSUnsupportedProxiableUUID\",\"inputs\":[{\"name\":\"slot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}]},{\"type\":\"error\",\"name\":\"UnstakeRequestExists\",\"inputs\":[{\"name\":\"sender\",\"type\":\"address\",\"internalType\":\"address\"}]}]", } // ProviderregistryABI is the input ABI used to generate the binding from. @@ -273,6 +273,37 @@ func (_Providerregistry *ProviderregistryCallerSession) UPGRADEINTERFACEVERSION( return _Providerregistry.Contract.UPGRADEINTERFACEVERSION(&_Providerregistry.CallOpts) } +// ApproverLockCount is a free data retrieval call binding the contract method 0x88840350. +// +// Solidity: function approverLockCount(address ) view returns(uint256) +func (_Providerregistry *ProviderregistryCaller) ApproverLockCount(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _Providerregistry.contract.Call(opts, &out, "approverLockCount", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ApproverLockCount is a free data retrieval call binding the contract method 0x88840350. +// +// Solidity: function approverLockCount(address ) view returns(uint256) +func (_Providerregistry *ProviderregistrySession) ApproverLockCount(arg0 common.Address) (*big.Int, error) { + return _Providerregistry.Contract.ApproverLockCount(&_Providerregistry.CallOpts, arg0) +} + +// ApproverLockCount is a free data retrieval call binding the contract method 0x88840350. +// +// Solidity: function approverLockCount(address ) view returns(uint256) +func (_Providerregistry *ProviderregistryCallerSession) ApproverLockCount(arg0 common.Address) (*big.Int, error) { + return _Providerregistry.Contract.ApproverLockCount(&_Providerregistry.CallOpts, arg0) +} + // AreProvidersValid is a free data retrieval call binding the contract method 0x8dc4ce17. // // Solidity: function areProvidersValid(address[] providers) view returns(bool[]) @@ -760,6 +791,37 @@ func (_Providerregistry *ProviderregistryCallerSession) PendingOwner() (common.A return _Providerregistry.Contract.PendingOwner(&_Providerregistry.CallOpts) } +// PendingReputationStake is a free data retrieval call binding the contract method 0x06e7a47e. +// +// Solidity: function pendingReputationStake(address ) view returns(uint256) +func (_Providerregistry *ProviderregistryCaller) PendingReputationStake(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { + var out []interface{} + err := _Providerregistry.contract.Call(opts, &out, "pendingReputationStake", arg0) + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// PendingReputationStake is a free data retrieval call binding the contract method 0x06e7a47e. +// +// Solidity: function pendingReputationStake(address ) view returns(uint256) +func (_Providerregistry *ProviderregistrySession) PendingReputationStake(arg0 common.Address) (*big.Int, error) { + return _Providerregistry.Contract.PendingReputationStake(&_Providerregistry.CallOpts, arg0) +} + +// PendingReputationStake is a free data retrieval call binding the contract method 0x06e7a47e. +// +// Solidity: function pendingReputationStake(address ) view returns(uint256) +func (_Providerregistry *ProviderregistryCallerSession) PendingReputationStake(arg0 common.Address) (*big.Int, error) { + return _Providerregistry.Contract.PendingReputationStake(&_Providerregistry.CallOpts, arg0) +} + // PreconfManager is a free data retrieval call binding the contract method 0x94a87500. // // Solidity: function preconfManager() view returns(address) @@ -884,6 +946,68 @@ func (_Providerregistry *ProviderregistryCallerSession) ProxiableUUID() ([32]byt return _Providerregistry.Contract.ProxiableUUID(&_Providerregistry.CallOpts) } +// ReputationMinStake is a free data retrieval call binding the contract method 0x9699bc47. +// +// Solidity: function reputationMinStake() view returns(uint256) +func (_Providerregistry *ProviderregistryCaller) ReputationMinStake(opts *bind.CallOpts) (*big.Int, error) { + var out []interface{} + err := _Providerregistry.contract.Call(opts, &out, "reputationMinStake") + + if err != nil { + return *new(*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new(*big.Int)).(**big.Int) + + return out0, err + +} + +// ReputationMinStake is a free data retrieval call binding the contract method 0x9699bc47. +// +// Solidity: function reputationMinStake() view returns(uint256) +func (_Providerregistry *ProviderregistrySession) ReputationMinStake() (*big.Int, error) { + return _Providerregistry.Contract.ReputationMinStake(&_Providerregistry.CallOpts) +} + +// ReputationMinStake is a free data retrieval call binding the contract method 0x9699bc47. +// +// Solidity: function reputationMinStake() view returns(uint256) +func (_Providerregistry *ProviderregistryCallerSession) ReputationMinStake() (*big.Int, error) { + return _Providerregistry.Contract.ReputationMinStake(&_Providerregistry.CallOpts) +} + +// ReputationProviderApprover is a free data retrieval call binding the contract method 0x7c771a22. +// +// Solidity: function reputationProviderApprover(address ) view returns(address) +func (_Providerregistry *ProviderregistryCaller) ReputationProviderApprover(opts *bind.CallOpts, arg0 common.Address) (common.Address, error) { + var out []interface{} + err := _Providerregistry.contract.Call(opts, &out, "reputationProviderApprover", arg0) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// ReputationProviderApprover is a free data retrieval call binding the contract method 0x7c771a22. +// +// Solidity: function reputationProviderApprover(address ) view returns(address) +func (_Providerregistry *ProviderregistrySession) ReputationProviderApprover(arg0 common.Address) (common.Address, error) { + return _Providerregistry.Contract.ReputationProviderApprover(&_Providerregistry.CallOpts, arg0) +} + +// ReputationProviderApprover is a free data retrieval call binding the contract method 0x7c771a22. +// +// Solidity: function reputationProviderApprover(address ) view returns(address) +func (_Providerregistry *ProviderregistryCallerSession) ReputationProviderApprover(arg0 common.Address) (common.Address, error) { + return _Providerregistry.Contract.ReputationProviderApprover(&_Providerregistry.CallOpts, arg0) +} + // VerifySignature is a free data retrieval call binding the contract method 0x2222e36f. // // Solidity: function verifySignature(bytes pubKey, bytes32 message, bytes signature) view returns(bool) @@ -1019,6 +1143,48 @@ func (_Providerregistry *ProviderregistryTransactorSession) AddVerifiedBLSKey(bl return _Providerregistry.Contract.AddVerifiedBLSKey(&_Providerregistry.TransactOpts, blsPublicKey, signature) } +// ApproveReputationRegistration is a paid mutator transaction binding the contract method 0xc6af2b55. +// +// Solidity: function approveReputationRegistration(address provider) returns() +func (_Providerregistry *ProviderregistryTransactor) ApproveReputationRegistration(opts *bind.TransactOpts, provider common.Address) (*types.Transaction, error) { + return _Providerregistry.contract.Transact(opts, "approveReputationRegistration", provider) +} + +// ApproveReputationRegistration is a paid mutator transaction binding the contract method 0xc6af2b55. +// +// Solidity: function approveReputationRegistration(address provider) returns() +func (_Providerregistry *ProviderregistrySession) ApproveReputationRegistration(provider common.Address) (*types.Transaction, error) { + return _Providerregistry.Contract.ApproveReputationRegistration(&_Providerregistry.TransactOpts, provider) +} + +// ApproveReputationRegistration is a paid mutator transaction binding the contract method 0xc6af2b55. +// +// Solidity: function approveReputationRegistration(address provider) returns() +func (_Providerregistry *ProviderregistryTransactorSession) ApproveReputationRegistration(provider common.Address) (*types.Transaction, error) { + return _Providerregistry.Contract.ApproveReputationRegistration(&_Providerregistry.TransactOpts, provider) +} + +// CancelReputationRegistration is a paid mutator transaction binding the contract method 0x978d5b64. +// +// Solidity: function cancelReputationRegistration() returns() +func (_Providerregistry *ProviderregistryTransactor) CancelReputationRegistration(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Providerregistry.contract.Transact(opts, "cancelReputationRegistration") +} + +// CancelReputationRegistration is a paid mutator transaction binding the contract method 0x978d5b64. +// +// Solidity: function cancelReputationRegistration() returns() +func (_Providerregistry *ProviderregistrySession) CancelReputationRegistration() (*types.Transaction, error) { + return _Providerregistry.Contract.CancelReputationRegistration(&_Providerregistry.TransactOpts) +} + +// CancelReputationRegistration is a paid mutator transaction binding the contract method 0x978d5b64. +// +// Solidity: function cancelReputationRegistration() returns() +func (_Providerregistry *ProviderregistryTransactorSession) CancelReputationRegistration() (*types.Transaction, error) { + return _Providerregistry.Contract.CancelReputationRegistration(&_Providerregistry.TransactOpts) +} + // DelegateRegisterAndStake is a paid mutator transaction binding the contract method 0x3d75c0ba. // // Solidity: function delegateRegisterAndStake(address provider) payable returns() @@ -1187,6 +1353,27 @@ func (_Providerregistry *ProviderregistryTransactorSession) RegisterAndStake() ( return _Providerregistry.Contract.RegisterAndStake(&_Providerregistry.TransactOpts) } +// RemoveReputationProvider is a paid mutator transaction binding the contract method 0x837dc0ec. +// +// Solidity: function removeReputationProvider(address provider) returns() +func (_Providerregistry *ProviderregistryTransactor) RemoveReputationProvider(opts *bind.TransactOpts, provider common.Address) (*types.Transaction, error) { + return _Providerregistry.contract.Transact(opts, "removeReputationProvider", provider) +} + +// RemoveReputationProvider is a paid mutator transaction binding the contract method 0x837dc0ec. +// +// Solidity: function removeReputationProvider(address provider) returns() +func (_Providerregistry *ProviderregistrySession) RemoveReputationProvider(provider common.Address) (*types.Transaction, error) { + return _Providerregistry.Contract.RemoveReputationProvider(&_Providerregistry.TransactOpts, provider) +} + +// RemoveReputationProvider is a paid mutator transaction binding the contract method 0x837dc0ec. +// +// Solidity: function removeReputationProvider(address provider) returns() +func (_Providerregistry *ProviderregistryTransactorSession) RemoveReputationProvider(provider common.Address) (*types.Transaction, error) { + return _Providerregistry.Contract.RemoveReputationProvider(&_Providerregistry.TransactOpts, provider) +} + // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. // // Solidity: function renounceOwnership() returns() @@ -1208,6 +1395,27 @@ func (_Providerregistry *ProviderregistryTransactorSession) RenounceOwnership() return _Providerregistry.Contract.RenounceOwnership(&_Providerregistry.TransactOpts) } +// RequestReputationRegistration is a paid mutator transaction binding the contract method 0x0006f87e. +// +// Solidity: function requestReputationRegistration() payable returns() +func (_Providerregistry *ProviderregistryTransactor) RequestReputationRegistration(opts *bind.TransactOpts) (*types.Transaction, error) { + return _Providerregistry.contract.Transact(opts, "requestReputationRegistration") +} + +// RequestReputationRegistration is a paid mutator transaction binding the contract method 0x0006f87e. +// +// Solidity: function requestReputationRegistration() payable returns() +func (_Providerregistry *ProviderregistrySession) RequestReputationRegistration() (*types.Transaction, error) { + return _Providerregistry.Contract.RequestReputationRegistration(&_Providerregistry.TransactOpts) +} + +// RequestReputationRegistration is a paid mutator transaction binding the contract method 0x0006f87e. +// +// Solidity: function requestReputationRegistration() payable returns() +func (_Providerregistry *ProviderregistryTransactorSession) RequestReputationRegistration() (*types.Transaction, error) { + return _Providerregistry.Contract.RequestReputationRegistration(&_Providerregistry.TransactOpts) +} + // SetFeePayoutPeriod is a paid mutator transaction binding the contract method 0xcc5ad073. // // Solidity: function setFeePayoutPeriod(uint256 _feePayoutPeriod) returns() @@ -1313,6 +1521,27 @@ func (_Providerregistry *ProviderregistryTransactorSession) SetPreconfManager(co return _Providerregistry.Contract.SetPreconfManager(&_Providerregistry.TransactOpts, contractAddress) } +// SetReputationMinStake is a paid mutator transaction binding the contract method 0x90e7f8c5. +// +// Solidity: function setReputationMinStake(uint256 _reputationMinStake) returns() +func (_Providerregistry *ProviderregistryTransactor) SetReputationMinStake(opts *bind.TransactOpts, _reputationMinStake *big.Int) (*types.Transaction, error) { + return _Providerregistry.contract.Transact(opts, "setReputationMinStake", _reputationMinStake) +} + +// SetReputationMinStake is a paid mutator transaction binding the contract method 0x90e7f8c5. +// +// Solidity: function setReputationMinStake(uint256 _reputationMinStake) returns() +func (_Providerregistry *ProviderregistrySession) SetReputationMinStake(_reputationMinStake *big.Int) (*types.Transaction, error) { + return _Providerregistry.Contract.SetReputationMinStake(&_Providerregistry.TransactOpts, _reputationMinStake) +} + +// SetReputationMinStake is a paid mutator transaction binding the contract method 0x90e7f8c5. +// +// Solidity: function setReputationMinStake(uint256 _reputationMinStake) returns() +func (_Providerregistry *ProviderregistryTransactorSession) SetReputationMinStake(_reputationMinStake *big.Int) (*types.Transaction, error) { + return _Providerregistry.Contract.SetReputationMinStake(&_Providerregistry.TransactOpts, _reputationMinStake) +} + // SetWithdrawalDelay is a paid mutator transaction binding the contract method 0xd2c13da5. // // Solidity: function setWithdrawalDelay(uint256 _withdrawalDelay) returns() @@ -3990,6 +4219,746 @@ func (_Providerregistry *ProviderregistryFilterer) ParseProviderRegistered(log t return event, nil } +// ProviderregistryReputationMinStakeUpdatedIterator is returned from FilterReputationMinStakeUpdated and is used to iterate over the raw logs and unpacked data for ReputationMinStakeUpdated events raised by the Providerregistry contract. +type ProviderregistryReputationMinStakeUpdatedIterator struct { + Event *ProviderregistryReputationMinStakeUpdated // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ProviderregistryReputationMinStakeUpdatedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ProviderregistryReputationMinStakeUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ProviderregistryReputationMinStakeUpdated) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ProviderregistryReputationMinStakeUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ProviderregistryReputationMinStakeUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ProviderregistryReputationMinStakeUpdated represents a ReputationMinStakeUpdated event raised by the Providerregistry contract. +type ProviderregistryReputationMinStakeUpdated struct { + NewMinStake *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReputationMinStakeUpdated is a free log retrieval operation binding the contract event 0x7fffb267a9a746c24b2302a86ec5dc3c2fc3a6d8265f3edafb18a3bcbc3e8f58. +// +// Solidity: event ReputationMinStakeUpdated(uint256 indexed newMinStake) +func (_Providerregistry *ProviderregistryFilterer) FilterReputationMinStakeUpdated(opts *bind.FilterOpts, newMinStake []*big.Int) (*ProviderregistryReputationMinStakeUpdatedIterator, error) { + + var newMinStakeRule []interface{} + for _, newMinStakeItem := range newMinStake { + newMinStakeRule = append(newMinStakeRule, newMinStakeItem) + } + + logs, sub, err := _Providerregistry.contract.FilterLogs(opts, "ReputationMinStakeUpdated", newMinStakeRule) + if err != nil { + return nil, err + } + return &ProviderregistryReputationMinStakeUpdatedIterator{contract: _Providerregistry.contract, event: "ReputationMinStakeUpdated", logs: logs, sub: sub}, nil +} + +// WatchReputationMinStakeUpdated is a free log subscription operation binding the contract event 0x7fffb267a9a746c24b2302a86ec5dc3c2fc3a6d8265f3edafb18a3bcbc3e8f58. +// +// Solidity: event ReputationMinStakeUpdated(uint256 indexed newMinStake) +func (_Providerregistry *ProviderregistryFilterer) WatchReputationMinStakeUpdated(opts *bind.WatchOpts, sink chan<- *ProviderregistryReputationMinStakeUpdated, newMinStake []*big.Int) (event.Subscription, error) { + + var newMinStakeRule []interface{} + for _, newMinStakeItem := range newMinStake { + newMinStakeRule = append(newMinStakeRule, newMinStakeItem) + } + + logs, sub, err := _Providerregistry.contract.WatchLogs(opts, "ReputationMinStakeUpdated", newMinStakeRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ProviderregistryReputationMinStakeUpdated) + if err := _Providerregistry.contract.UnpackLog(event, "ReputationMinStakeUpdated", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseReputationMinStakeUpdated is a log parse operation binding the contract event 0x7fffb267a9a746c24b2302a86ec5dc3c2fc3a6d8265f3edafb18a3bcbc3e8f58. +// +// Solidity: event ReputationMinStakeUpdated(uint256 indexed newMinStake) +func (_Providerregistry *ProviderregistryFilterer) ParseReputationMinStakeUpdated(log types.Log) (*ProviderregistryReputationMinStakeUpdated, error) { + event := new(ProviderregistryReputationMinStakeUpdated) + if err := _Providerregistry.contract.UnpackLog(event, "ReputationMinStakeUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ProviderregistryReputationProviderApprovedIterator is returned from FilterReputationProviderApproved and is used to iterate over the raw logs and unpacked data for ReputationProviderApproved events raised by the Providerregistry contract. +type ProviderregistryReputationProviderApprovedIterator struct { + Event *ProviderregistryReputationProviderApproved // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ProviderregistryReputationProviderApprovedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ProviderregistryReputationProviderApproved) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ProviderregistryReputationProviderApproved) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ProviderregistryReputationProviderApprovedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ProviderregistryReputationProviderApprovedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ProviderregistryReputationProviderApproved represents a ReputationProviderApproved event raised by the Providerregistry contract. +type ProviderregistryReputationProviderApproved struct { + Provider common.Address + Approver common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReputationProviderApproved is a free log retrieval operation binding the contract event 0x79451cd32b3a9227e2922f5af4a3b2017649d02aa27cc42c34cae486afd9edc2. +// +// Solidity: event ReputationProviderApproved(address indexed provider, address indexed approver) +func (_Providerregistry *ProviderregistryFilterer) FilterReputationProviderApproved(opts *bind.FilterOpts, provider []common.Address, approver []common.Address) (*ProviderregistryReputationProviderApprovedIterator, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + var approverRule []interface{} + for _, approverItem := range approver { + approverRule = append(approverRule, approverItem) + } + + logs, sub, err := _Providerregistry.contract.FilterLogs(opts, "ReputationProviderApproved", providerRule, approverRule) + if err != nil { + return nil, err + } + return &ProviderregistryReputationProviderApprovedIterator{contract: _Providerregistry.contract, event: "ReputationProviderApproved", logs: logs, sub: sub}, nil +} + +// WatchReputationProviderApproved is a free log subscription operation binding the contract event 0x79451cd32b3a9227e2922f5af4a3b2017649d02aa27cc42c34cae486afd9edc2. +// +// Solidity: event ReputationProviderApproved(address indexed provider, address indexed approver) +func (_Providerregistry *ProviderregistryFilterer) WatchReputationProviderApproved(opts *bind.WatchOpts, sink chan<- *ProviderregistryReputationProviderApproved, provider []common.Address, approver []common.Address) (event.Subscription, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + var approverRule []interface{} + for _, approverItem := range approver { + approverRule = append(approverRule, approverItem) + } + + logs, sub, err := _Providerregistry.contract.WatchLogs(opts, "ReputationProviderApproved", providerRule, approverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ProviderregistryReputationProviderApproved) + if err := _Providerregistry.contract.UnpackLog(event, "ReputationProviderApproved", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseReputationProviderApproved is a log parse operation binding the contract event 0x79451cd32b3a9227e2922f5af4a3b2017649d02aa27cc42c34cae486afd9edc2. +// +// Solidity: event ReputationProviderApproved(address indexed provider, address indexed approver) +func (_Providerregistry *ProviderregistryFilterer) ParseReputationProviderApproved(log types.Log) (*ProviderregistryReputationProviderApproved, error) { + event := new(ProviderregistryReputationProviderApproved) + if err := _Providerregistry.contract.UnpackLog(event, "ReputationProviderApproved", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ProviderregistryReputationProviderRemovedIterator is returned from FilterReputationProviderRemoved and is used to iterate over the raw logs and unpacked data for ReputationProviderRemoved events raised by the Providerregistry contract. +type ProviderregistryReputationProviderRemovedIterator struct { + Event *ProviderregistryReputationProviderRemoved // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ProviderregistryReputationProviderRemovedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ProviderregistryReputationProviderRemoved) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ProviderregistryReputationProviderRemoved) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ProviderregistryReputationProviderRemovedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ProviderregistryReputationProviderRemovedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ProviderregistryReputationProviderRemoved represents a ReputationProviderRemoved event raised by the Providerregistry contract. +type ProviderregistryReputationProviderRemoved struct { + Provider common.Address + Approver common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReputationProviderRemoved is a free log retrieval operation binding the contract event 0x6cb8d03d0df35faf0c47105af1d1f9b3d9be8917ad00dd31355c204712cf45ef. +// +// Solidity: event ReputationProviderRemoved(address indexed provider, address indexed approver) +func (_Providerregistry *ProviderregistryFilterer) FilterReputationProviderRemoved(opts *bind.FilterOpts, provider []common.Address, approver []common.Address) (*ProviderregistryReputationProviderRemovedIterator, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + var approverRule []interface{} + for _, approverItem := range approver { + approverRule = append(approverRule, approverItem) + } + + logs, sub, err := _Providerregistry.contract.FilterLogs(opts, "ReputationProviderRemoved", providerRule, approverRule) + if err != nil { + return nil, err + } + return &ProviderregistryReputationProviderRemovedIterator{contract: _Providerregistry.contract, event: "ReputationProviderRemoved", logs: logs, sub: sub}, nil +} + +// WatchReputationProviderRemoved is a free log subscription operation binding the contract event 0x6cb8d03d0df35faf0c47105af1d1f9b3d9be8917ad00dd31355c204712cf45ef. +// +// Solidity: event ReputationProviderRemoved(address indexed provider, address indexed approver) +func (_Providerregistry *ProviderregistryFilterer) WatchReputationProviderRemoved(opts *bind.WatchOpts, sink chan<- *ProviderregistryReputationProviderRemoved, provider []common.Address, approver []common.Address) (event.Subscription, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + var approverRule []interface{} + for _, approverItem := range approver { + approverRule = append(approverRule, approverItem) + } + + logs, sub, err := _Providerregistry.contract.WatchLogs(opts, "ReputationProviderRemoved", providerRule, approverRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ProviderregistryReputationProviderRemoved) + if err := _Providerregistry.contract.UnpackLog(event, "ReputationProviderRemoved", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseReputationProviderRemoved is a log parse operation binding the contract event 0x6cb8d03d0df35faf0c47105af1d1f9b3d9be8917ad00dd31355c204712cf45ef. +// +// Solidity: event ReputationProviderRemoved(address indexed provider, address indexed approver) +func (_Providerregistry *ProviderregistryFilterer) ParseReputationProviderRemoved(log types.Log) (*ProviderregistryReputationProviderRemoved, error) { + event := new(ProviderregistryReputationProviderRemoved) + if err := _Providerregistry.contract.UnpackLog(event, "ReputationProviderRemoved", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ProviderregistryReputationRegistrationCancelledIterator is returned from FilterReputationRegistrationCancelled and is used to iterate over the raw logs and unpacked data for ReputationRegistrationCancelled events raised by the Providerregistry contract. +type ProviderregistryReputationRegistrationCancelledIterator struct { + Event *ProviderregistryReputationRegistrationCancelled // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ProviderregistryReputationRegistrationCancelledIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ProviderregistryReputationRegistrationCancelled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ProviderregistryReputationRegistrationCancelled) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ProviderregistryReputationRegistrationCancelledIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ProviderregistryReputationRegistrationCancelledIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ProviderregistryReputationRegistrationCancelled represents a ReputationRegistrationCancelled event raised by the Providerregistry contract. +type ProviderregistryReputationRegistrationCancelled struct { + Provider common.Address + ReturnedAmount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReputationRegistrationCancelled is a free log retrieval operation binding the contract event 0xc764e016b0eb5a1d243cbdccbb6526b09d48e837d576e23df9058d43be0f1b91. +// +// Solidity: event ReputationRegistrationCancelled(address indexed provider, uint256 returnedAmount) +func (_Providerregistry *ProviderregistryFilterer) FilterReputationRegistrationCancelled(opts *bind.FilterOpts, provider []common.Address) (*ProviderregistryReputationRegistrationCancelledIterator, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Providerregistry.contract.FilterLogs(opts, "ReputationRegistrationCancelled", providerRule) + if err != nil { + return nil, err + } + return &ProviderregistryReputationRegistrationCancelledIterator{contract: _Providerregistry.contract, event: "ReputationRegistrationCancelled", logs: logs, sub: sub}, nil +} + +// WatchReputationRegistrationCancelled is a free log subscription operation binding the contract event 0xc764e016b0eb5a1d243cbdccbb6526b09d48e837d576e23df9058d43be0f1b91. +// +// Solidity: event ReputationRegistrationCancelled(address indexed provider, uint256 returnedAmount) +func (_Providerregistry *ProviderregistryFilterer) WatchReputationRegistrationCancelled(opts *bind.WatchOpts, sink chan<- *ProviderregistryReputationRegistrationCancelled, provider []common.Address) (event.Subscription, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Providerregistry.contract.WatchLogs(opts, "ReputationRegistrationCancelled", providerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ProviderregistryReputationRegistrationCancelled) + if err := _Providerregistry.contract.UnpackLog(event, "ReputationRegistrationCancelled", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseReputationRegistrationCancelled is a log parse operation binding the contract event 0xc764e016b0eb5a1d243cbdccbb6526b09d48e837d576e23df9058d43be0f1b91. +// +// Solidity: event ReputationRegistrationCancelled(address indexed provider, uint256 returnedAmount) +func (_Providerregistry *ProviderregistryFilterer) ParseReputationRegistrationCancelled(log types.Log) (*ProviderregistryReputationRegistrationCancelled, error) { + event := new(ProviderregistryReputationRegistrationCancelled) + if err := _Providerregistry.contract.UnpackLog(event, "ReputationRegistrationCancelled", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ProviderregistryReputationRegistrationRequestedIterator is returned from FilterReputationRegistrationRequested and is used to iterate over the raw logs and unpacked data for ReputationRegistrationRequested events raised by the Providerregistry contract. +type ProviderregistryReputationRegistrationRequestedIterator struct { + Event *ProviderregistryReputationRegistrationRequested // Event containing the contract specifics and raw log + + contract *bind.BoundContract // Generic contract to use for unpacking event data + event string // Event name to use for unpacking event data + + logs chan types.Log // Log channel receiving the found contract events + sub ethereum.Subscription // Subscription for errors, completion and termination + done bool // Whether the subscription completed delivering logs + fail error // Occurred error to stop iteration +} + +// Next advances the iterator to the subsequent event, returning whether there +// are any more events found. In case of a retrieval or parsing error, false is +// returned and Error() can be queried for the exact failure. +func (it *ProviderregistryReputationRegistrationRequestedIterator) Next() bool { + // If the iterator failed, stop iterating + if it.fail != nil { + return false + } + // If the iterator completed, deliver directly whatever's available + if it.done { + select { + case log := <-it.logs: + it.Event = new(ProviderregistryReputationRegistrationRequested) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + default: + return false + } + } + // Iterator still in progress, wait for either a data or an error event + select { + case log := <-it.logs: + it.Event = new(ProviderregistryReputationRegistrationRequested) + if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { + it.fail = err + return false + } + it.Event.Raw = log + return true + + case err := <-it.sub.Err(): + it.done = true + it.fail = err + return it.Next() + } +} + +// Error returns any retrieval or parsing error occurred during filtering. +func (it *ProviderregistryReputationRegistrationRequestedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ProviderregistryReputationRegistrationRequestedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ProviderregistryReputationRegistrationRequested represents a ReputationRegistrationRequested event raised by the Providerregistry contract. +type ProviderregistryReputationRegistrationRequested struct { + Provider common.Address + StakedAmount *big.Int + Raw types.Log // Blockchain specific contextual infos +} + +// FilterReputationRegistrationRequested is a free log retrieval operation binding the contract event 0x600ed5d02115fda19ed1fa3ae90c63856a72f339a555617378323d7d6d487c8c. +// +// Solidity: event ReputationRegistrationRequested(address indexed provider, uint256 stakedAmount) +func (_Providerregistry *ProviderregistryFilterer) FilterReputationRegistrationRequested(opts *bind.FilterOpts, provider []common.Address) (*ProviderregistryReputationRegistrationRequestedIterator, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Providerregistry.contract.FilterLogs(opts, "ReputationRegistrationRequested", providerRule) + if err != nil { + return nil, err + } + return &ProviderregistryReputationRegistrationRequestedIterator{contract: _Providerregistry.contract, event: "ReputationRegistrationRequested", logs: logs, sub: sub}, nil +} + +// WatchReputationRegistrationRequested is a free log subscription operation binding the contract event 0x600ed5d02115fda19ed1fa3ae90c63856a72f339a555617378323d7d6d487c8c. +// +// Solidity: event ReputationRegistrationRequested(address indexed provider, uint256 stakedAmount) +func (_Providerregistry *ProviderregistryFilterer) WatchReputationRegistrationRequested(opts *bind.WatchOpts, sink chan<- *ProviderregistryReputationRegistrationRequested, provider []common.Address) (event.Subscription, error) { + + var providerRule []interface{} + for _, providerItem := range provider { + providerRule = append(providerRule, providerItem) + } + + logs, sub, err := _Providerregistry.contract.WatchLogs(opts, "ReputationRegistrationRequested", providerRule) + if err != nil { + return nil, err + } + return event.NewSubscription(func(quit <-chan struct{}) error { + defer sub.Unsubscribe() + for { + select { + case log := <-logs: + // New log arrived, parse the event and forward to the user + event := new(ProviderregistryReputationRegistrationRequested) + if err := _Providerregistry.contract.UnpackLog(event, "ReputationRegistrationRequested", log); err != nil { + return err + } + event.Raw = log + + select { + case sink <- event: + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + case err := <-sub.Err(): + return err + case <-quit: + return nil + } + } + }), nil +} + +// ParseReputationRegistrationRequested is a log parse operation binding the contract event 0x600ed5d02115fda19ed1fa3ae90c63856a72f339a555617378323d7d6d487c8c. +// +// Solidity: event ReputationRegistrationRequested(address indexed provider, uint256 stakedAmount) +func (_Providerregistry *ProviderregistryFilterer) ParseReputationRegistrationRequested(log types.Log) (*ProviderregistryReputationRegistrationRequested, error) { + event := new(ProviderregistryReputationRegistrationRequested) + if err := _Providerregistry.contract.UnpackLog(event, "ReputationRegistrationRequested", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + // ProviderregistryTransferToBidderFailedIterator is returned from FilterTransferToBidderFailed and is used to iterate over the raw logs and unpacked data for TransferToBidderFailed events raised by the Providerregistry contract. type ProviderregistryTransferToBidderFailedIterator struct { Event *ProviderregistryTransferToBidderFailed // Event containing the contract specifics and raw log From 08283fc3c9cb9cb33f9988647fbd9c0293ed2b83 Mon Sep 17 00:00:00 2001 From: owen-eth Date: Mon, 23 Mar 2026 03:44:52 -0400 Subject: [PATCH 3/4] fix solhint err --- contracts/contracts/core/ProviderRegistry.sol | 64 +++++++++---------- 1 file changed, 32 insertions(+), 32 deletions(-) diff --git a/contracts/contracts/core/ProviderRegistry.sol b/contracts/contracts/core/ProviderRegistry.sol index 3128717d0..45463e048 100644 --- a/contracts/contracts/core/ProviderRegistry.sol +++ b/contracts/contracts/core/ProviderRegistry.sol @@ -483,37 +483,6 @@ contract ProviderRegistry is return result.length > 0; } - function _stake(address provider) internal { - require(providerRegistered[provider], ProviderNotRegistered(provider)); - require( - withdrawalRequests[provider] == 0, - PendingWithdrawalRequest(provider) - ); - providerStakes[provider] += msg.value; - emit FundsDeposited(provider, msg.value); - - // Auto-convert reputation provider to standard if they reach minStake - if (reputationProviderApprover[provider] != address(0) && providerStakes[provider] >= minStake) { - address approver = reputationProviderApprover[provider]; - delete reputationProviderApprover[provider]; - if (approver != owner()) { - --approverLockCount[approver]; - } - } - } - - function _registerAndStake(address provider) internal { - require( - !providerRegistered[provider], - ProviderAlreadyRegistered(provider) - ); - require(msg.value >= minStake, InsufficientStake(msg.value, minStake)); - - providerStakes[provider] = msg.value; - providerRegistered[provider] = true; - emit ProviderRegistered(provider, msg.value); - } - /// @dev Sets the minimum stake for reputation providers. Can only be called by the owner. function setReputationMinStake(uint256 _reputationMinStake) external onlyOwner { reputationMinStake = _reputationMinStake; @@ -565,7 +534,7 @@ contract ProviderRegistry is emit ReputationProviderApproved(provider, msg.sender); } - /// @dev Remove a reputation provider. Callable by the approver or owner. + /// @dev Remove a reputation provider. Callable only by the approver. function removeReputationProvider(address provider) external whenNotPaused { address approver = reputationProviderApprover[provider]; require(approver != address(0), ProviderIsNotReputationProvider(provider)); @@ -590,6 +559,37 @@ contract ProviderRegistry is emit ReputationProviderRemoved(provider, approver); } + function _stake(address provider) internal { + require(providerRegistered[provider], ProviderNotRegistered(provider)); + require( + withdrawalRequests[provider] == 0, + PendingWithdrawalRequest(provider) + ); + providerStakes[provider] += msg.value; + emit FundsDeposited(provider, msg.value); + + // Auto-convert reputation provider to standard if they reach minStake + if (reputationProviderApprover[provider] != address(0) && providerStakes[provider] >= minStake) { + address approver = reputationProviderApprover[provider]; + delete reputationProviderApprover[provider]; + if (approver != owner()) { + --approverLockCount[approver]; + } + } + } + + function _registerAndStake(address provider) internal { + require( + !providerRegistered[provider], + ProviderAlreadyRegistered(provider) + ); + require(msg.value >= minStake, InsufficientStake(msg.value, minStake)); + + providerStakes[provider] = msg.value; + providerRegistered[provider] = true; + emit ProviderRegistered(provider, msg.value); + } + // solhint-disable-next-line no-empty-blocks function _authorizeUpgrade(address) internal override onlyOwner {} } From 6dc26057fc207f252af65a24b48ac35848809833 Mon Sep 17 00:00:00 2001 From: owen-eth Date: Mon, 23 Mar 2026 04:13:20 -0400 Subject: [PATCH 4/4] more solhint fixes --- contracts/contracts/core/ProviderRegistry.sol | 150 +++++++++--------- .../interfaces/IProviderRegistry.sol | 12 +- 2 files changed, 80 insertions(+), 82 deletions(-) diff --git a/contracts/contracts/core/ProviderRegistry.sol b/contracts/contracts/core/ProviderRegistry.sol index 45463e048..d8c43dc65 100644 --- a/contracts/contracts/core/ProviderRegistry.sol +++ b/contracts/contracts/core/ProviderRegistry.sol @@ -373,6 +373,80 @@ contract ProviderRegistry is _unpause(); } + /// @dev Sets the minimum stake for reputation providers. Can only be called by the owner. + function setReputationMinStake(uint256 _reputationMinStake) external onlyOwner { + reputationMinStake = _reputationMinStake; + emit ReputationMinStakeUpdated(_reputationMinStake); + } + + /// @dev Request registration as a reputation provider. Must send >= reputationMinStake. + function requestReputationRegistration() external payable whenNotPaused { + require(!providerRegistered[msg.sender], ProviderAlreadyRegistered(msg.sender)); + require(pendingReputationStake[msg.sender] == 0, PendingReputationRequestExists(msg.sender)); + require(reputationMinStake != 0, InsufficientReputationStake(0, 0)); + require(msg.value >= reputationMinStake, InsufficientReputationStake(msg.value, reputationMinStake)); + + pendingReputationStake[msg.sender] = msg.value; + emit ReputationRegistrationRequested(msg.sender, msg.value); + } + + /// @dev Cancel a pending reputation registration request and get ETH back. + function cancelReputationRegistration() external nonReentrant whenNotPaused { + uint256 amount = pendingReputationStake[msg.sender]; + require(amount != 0, NoPendingReputationRequest(msg.sender)); + + delete pendingReputationStake[msg.sender]; + + (bool success, ) = msg.sender.call{value: amount}(""); + require(success, StakeTransferFailed(msg.sender, amount)); + + emit ReputationRegistrationCancelled(msg.sender, amount); + } + + /// @dev Approve a pending reputation provider. Callable by owner or a registered provider with >= minStake. + function approveReputationRegistration(address provider) external whenNotPaused { + uint256 amount = pendingReputationStake[provider]; + require(amount != 0, NoPendingReputationRequest(provider)); + + if (msg.sender != owner()) { + require(providerRegistered[msg.sender], ProviderNotRegistered(msg.sender)); + require(providerStakes[msg.sender] >= minStake, InsufficientStake(providerStakes[msg.sender], minStake)); + ++approverLockCount[msg.sender]; + } + + delete pendingReputationStake[provider]; + + providerStakes[provider] = amount; + providerRegistered[provider] = true; + reputationProviderApprover[provider] = msg.sender; + + emit ProviderRegistered(provider, amount); + emit ReputationProviderApproved(provider, msg.sender); + } + + /// @dev Remove a reputation provider. Callable only by the approver. + function removeReputationProvider(address provider) external whenNotPaused { + address approver = reputationProviderApprover[provider]; + require(approver != address(0), ProviderIsNotReputationProvider(provider)); + + require(msg.sender == approver, NotApprover(msg.sender)); + + delete reputationProviderApprover[provider]; + + if (approver != owner()) { + --approverLockCount[approver]; + } + + if (providerStakes[provider] == 0) { + providerRegistered[provider] = false; + } else if (withdrawalRequests[provider] == 0) { + withdrawalRequests[provider] = block.timestamp; + emit Unstake(provider, block.timestamp); + } + + emit ReputationProviderRemoved(provider, approver); + } + /** * @dev Get provider staked amount. * @param provider The address of the provider. @@ -483,82 +557,6 @@ contract ProviderRegistry is return result.length > 0; } - /// @dev Sets the minimum stake for reputation providers. Can only be called by the owner. - function setReputationMinStake(uint256 _reputationMinStake) external onlyOwner { - reputationMinStake = _reputationMinStake; - emit ReputationMinStakeUpdated(_reputationMinStake); - } - - /// @dev Request registration as a reputation provider. Must send >= reputationMinStake. - function requestReputationRegistration() external payable whenNotPaused { - require(!providerRegistered[msg.sender], ProviderAlreadyRegistered(msg.sender)); - require(pendingReputationStake[msg.sender] == 0, PendingReputationRequestExists(msg.sender)); - require(reputationMinStake != 0, InsufficientReputationStake(0, 0)); - require(msg.value >= reputationMinStake, InsufficientReputationStake(msg.value, reputationMinStake)); - - pendingReputationStake[msg.sender] = msg.value; - emit ReputationRegistrationRequested(msg.sender, msg.value); - } - - /// @dev Cancel a pending reputation registration request and get ETH back. - function cancelReputationRegistration() external nonReentrant whenNotPaused { - uint256 amount = pendingReputationStake[msg.sender]; - require(amount != 0, NoPendingReputationRequest(msg.sender)); - - delete pendingReputationStake[msg.sender]; - - (bool success, ) = msg.sender.call{value: amount}(""); - require(success, StakeTransferFailed(msg.sender, amount)); - - emit ReputationRegistrationCancelled(msg.sender, amount); - } - - /// @dev Approve a pending reputation provider. Callable by owner or a registered provider with >= minStake. - function approveReputationRegistration(address provider) external whenNotPaused { - uint256 amount = pendingReputationStake[provider]; - require(amount != 0, NoPendingReputationRequest(provider)); - - if (msg.sender != owner()) { - require(providerRegistered[msg.sender], ProviderNotRegistered(msg.sender)); - require(providerStakes[msg.sender] >= minStake, InsufficientStake(providerStakes[msg.sender], minStake)); - ++approverLockCount[msg.sender]; - } - - delete pendingReputationStake[provider]; - - providerStakes[provider] = amount; - providerRegistered[provider] = true; - reputationProviderApprover[provider] = msg.sender; - - emit ProviderRegistered(provider, amount); - emit ReputationProviderApproved(provider, msg.sender); - } - - /// @dev Remove a reputation provider. Callable only by the approver. - function removeReputationProvider(address provider) external whenNotPaused { - address approver = reputationProviderApprover[provider]; - require(approver != address(0), ProviderIsNotReputationProvider(provider)); - - require(msg.sender == approver, NotApprover(msg.sender)); - - delete reputationProviderApprover[provider]; - - if (approver != owner()) { - --approverLockCount[approver]; - } - - if (providerStakes[provider] == 0) { - // Fully slashed — just deregister - providerRegistered[provider] = false; - } else if (withdrawalRequests[provider] == 0) { - // Start the unstake process so they can withdraw after cooldown - withdrawalRequests[provider] = block.timestamp; - emit Unstake(provider, block.timestamp); - } - - emit ReputationProviderRemoved(provider, approver); - } - function _stake(address provider) internal { require(providerRegistered[provider], ProviderNotRegistered(provider)); require( diff --git a/contracts/contracts/interfaces/IProviderRegistry.sol b/contracts/contracts/interfaces/IProviderRegistry.sol index 9ed577e8b..f9272a7ff 100644 --- a/contracts/contracts/interfaces/IProviderRegistry.sol +++ b/contracts/contracts/interfaces/IProviderRegistry.sol @@ -57,6 +57,12 @@ interface IProviderRegistry { /// in case of transfer failure event BidderWithdrawSlashedAmount(address bidder, uint256 amount); + event ReputationRegistrationRequested(address indexed provider, uint256 stakedAmount); + event ReputationRegistrationCancelled(address indexed provider, uint256 returnedAmount); + event ReputationProviderApproved(address indexed provider, address indexed approver); + event ReputationProviderRemoved(address indexed provider, address indexed approver); + event ReputationMinStakeUpdated(uint256 indexed newMinStake); + error NotPreconfContract(address sender, address preconfManager); error NoStakeToWithdraw(address sender); error UnstakeRequestExists(address sender); @@ -86,12 +92,6 @@ interface IProviderRegistry { error ProviderIsNotReputationProvider(address provider); error NotApprover(address sender); - event ReputationRegistrationRequested(address indexed provider, uint256 stakedAmount); - event ReputationRegistrationCancelled(address indexed provider, uint256 returnedAmount); - event ReputationProviderApproved(address indexed provider, address indexed approver); - event ReputationProviderRemoved(address indexed provider, address indexed approver); - event ReputationMinStakeUpdated(uint256 indexed newMinStake); - function registerAndStake() external payable; function stake() external payable;