From e11d077c4f6de821bb983a65e34f9f2abab49116 Mon Sep 17 00:00:00 2001 From: Michael Date: Mon, 16 Jun 2025 09:52:22 -0400 Subject: [PATCH 1/5] feat: ecdsa cert verifier --- .../multichain/ECDSACertificateVerifier.sol | 316 +++++++++++ .../ECDSACertificateVerifierStorage.sol | 46 ++ .../unit/ECDSACertificateVerifierUnit.t.sol | 514 ++++++++++++++++++ 3 files changed, 876 insertions(+) create mode 100644 src/contracts/multichain/ECDSACertificateVerifier.sol create mode 100644 src/contracts/multichain/ECDSACertificateVerifierStorage.sol create mode 100644 src/test/unit/ECDSACertificateVerifierUnit.t.sol diff --git a/src/contracts/multichain/ECDSACertificateVerifier.sol b/src/contracts/multichain/ECDSACertificateVerifier.sol new file mode 100644 index 0000000000..4bb99b72e4 --- /dev/null +++ b/src/contracts/multichain/ECDSACertificateVerifier.sol @@ -0,0 +1,316 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "@openzeppelin-upgrades/contracts/proxy/utils/Initializable.sol"; +import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; + +import {OperatorSet} from "../libraries/OperatorSetLib.sol"; +import "../mixins/SignatureUtilsMixin.sol"; +import "./ECDSACertificateVerifierStorage.sol"; + +/** + * @title ECDSACertificateVerifier + * @notice Verifies ECDSA certificates across multiple operator sets + * @dev Implements ECDSA signature verification with operator information caching + */ +contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStorage, SignatureUtilsMixin { + using ECDSA for bytes32; + + // EIP-712 type hash for certificate verification + bytes32 public constant ECDSA_CERTIFICATE_TYPEHASH = + keccak256("ECDSACertificate(uint32 referenceTimestamp,bytes32 messageHash)"); + + /** + * @notice Struct to hold verification context and reduce stack depth + */ + struct VerificationContext { + bytes32 operatorSetKey; + ECDSAOperatorInfo[] operatorInfos; + uint256[] signedStakes; + address[] nonSigners; + } + + /** + * @notice Restricts access to the operator table updater + */ + modifier onlyTableUpdater() { + require(msg.sender == address(operatorTableUpdater), OnlyTableUpdater()); + _; + } + + /** + * @notice Constructor for the certificate verifier + * @dev Disables initializers to prevent implementation initialization + * @param _operatorTableUpdater Address authorized to update operator tables + */ + constructor( + IOperatorTableUpdater _operatorTableUpdater + ) ECDSACertificateVerifierStorage(_operatorTableUpdater) SignatureUtilsMixin("1.0.0") { + _disableInitializers(); + } + + ///@inheritdoc IBaseCertificateVerifier + function getOperatorSetOwner( + OperatorSet memory operatorSet + ) external view returns (address) { + bytes32 operatorSetKey = operatorSet.key(); + return _operatorSetOwners[operatorSetKey]; + } + + ///@inheritdoc IBaseCertificateVerifier + function maxOperatorTableStaleness( + OperatorSet memory operatorSet + ) external view returns (uint32) { + bytes32 operatorSetKey = operatorSet.key(); + return _maxStalenessPeriods[operatorSetKey]; + } + + ///@inheritdoc IBaseCertificateVerifier + function latestReferenceTimestamp( + OperatorSet memory operatorSet + ) external view returns (uint32) { + bytes32 operatorSetKey = operatorSet.key(); + return _latestReferenceTimestamps[operatorSetKey]; + } + + ///@inheritdoc IECDSACertificateVerifier + function updateOperatorTable( + OperatorSet calldata operatorSet, + uint32 referenceTimestamp, + ECDSAOperatorInfo[] calldata operatorInfos, + OperatorSetConfig calldata operatorSetConfig + ) external onlyTableUpdater { + bytes32 operatorSetKey = operatorSet.key(); + + // Validate that the new timestamp is greater than the latest reference timestamp + require(referenceTimestamp > _latestReferenceTimestamps[operatorSetKey], TableUpdateStale()); + + // Store the number of operators + _numOperators[operatorSetKey][referenceTimestamp] = operatorInfos.length; + + // Store each operator info in the indexed mapping + for (uint256 i = 0; i < operatorInfos.length; i++) { + _operatorInfos[operatorSetKey][referenceTimestamp][uint32(i)] = operatorInfos[i]; + } + + _latestReferenceTimestamps[operatorSetKey] = referenceTimestamp; + _operatorSetOwners[operatorSetKey] = operatorSetConfig.owner; + _maxStalenessPeriods[operatorSetKey] = operatorSetConfig.maxStalenessPeriod; + + emit TableUpdated(operatorSet, referenceTimestamp, operatorInfos); + } + + ///@inheritdoc IECDSACertificateVerifier + function verifyCertificate( + OperatorSet calldata operatorSet, + ECDSACertificate calldata cert + ) external view returns (uint256[] memory) { + uint96[] memory signedStakes96 = _verifyECDSACertificate(operatorSet, cert); + uint256[] memory signedStakes = new uint256[](signedStakes96.length); + for (uint256 i = 0; i < signedStakes96.length; i++) { + signedStakes[i] = uint256(signedStakes96[i]); + } + return signedStakes; + } + + ///@inheritdoc IECDSACertificateVerifier + function verifyCertificateProportion( + OperatorSet calldata operatorSet, + ECDSACertificate calldata cert, + uint16[] calldata totalStakeProportionThresholds + ) external view returns (bool) { + uint96[] memory signedStakes96 = _verifyECDSACertificate(operatorSet, cert); + uint256[] memory signedStakes = new uint256[](signedStakes96.length); + for (uint256 i = 0; i < signedStakes96.length; i++) { + signedStakes[i] = uint256(signedStakes96[i]); + } + uint96[] memory totalStakes96 = _getTotalStakes(operatorSet, cert.referenceTimestamp); + uint256[] memory totalStakes = new uint256[](totalStakes96.length); + for (uint256 i = 0; i < totalStakes96.length; i++) { + totalStakes[i] = uint256(totalStakes96[i]); + } + require(signedStakes.length == totalStakeProportionThresholds.length, ArrayLengthMismatch()); + for (uint256 i = 0; i < signedStakes.length; i++) { + uint256 threshold = (totalStakes[i] * totalStakeProportionThresholds[i]) / 10_000; + if (signedStakes[i] < threshold) { + return false; + } + } + return true; + } + + ///@inheritdoc IECDSACertificateVerifier + function verifyCertificateNominal( + OperatorSet calldata operatorSet, + ECDSACertificate calldata cert, + uint256[] memory totalStakeNominalThresholds + ) external view returns (bool) { + uint96[] memory signedStakes96 = _verifyECDSACertificate(operatorSet, cert); + uint256[] memory signedStakes = new uint256[](signedStakes96.length); + for (uint256 i = 0; i < signedStakes96.length; i++) { + signedStakes[i] = uint256(signedStakes96[i]); + } + require(signedStakes.length == totalStakeNominalThresholds.length, "Length mismatch"); + for (uint256 i = 0; i < signedStakes.length; i++) { + if (signedStakes[i] < totalStakeNominalThresholds[i]) { + return false; + } + } + return true; + } + + /** + * @notice Internal function to verify a certificate + * @param cert The certificate to verify + * @return signedStakes The amount of stake that signed the certificate for each stake type + */ + function _verifyECDSACertificate( + OperatorSet calldata operatorSet, + ECDSACertificate calldata cert + ) internal view returns (uint96[] memory) { + bytes32 operatorSetKey = operatorSet.key(); + + // Assert that reference timestamp is not stale + require(block.timestamp <= cert.referenceTimestamp + _maxStalenessPeriods[operatorSetKey], CertificateStale()); + + // Assert that the reference timestamp exists + require(_latestReferenceTimestamps[operatorSetKey] == cert.referenceTimestamp, ReferenceTimestampDoesNotExist()); + + // Get the total stakes + uint96[] memory totalStakes = _getTotalStakes(operatorSet, cert.referenceTimestamp); + uint96[] memory signedStakes = new uint96[](totalStakes.length); + + // Compute the EIP-712 digest for signature recovery + bytes32 structHash = + keccak256(abi.encode(ECDSA_CERTIFICATE_TYPEHASH, cert.referenceTimestamp, cert.messageHash)); + bytes32 signableDigest = keccak256(abi.encodePacked("\x19\x01", domainSeparator(), structHash)); + + // Parse the signatures + (address[] memory signers, bool validSignatures) = _parseSignatures(signableDigest, cert.sig); + + require(validSignatures, VerificationFailed()); + + // Process each operator to check if they signed + uint256 operatorCount = _numOperators[operatorSetKey][cert.referenceTimestamp]; + for (uint256 i = 0; i < operatorCount; i++) { + // Check if this operator is in the signers list + bool isSigner = false; + for (uint256 j = 0; j < signers.length; j++) { + if (_operatorInfos[operatorSetKey][cert.referenceTimestamp][uint32(i)].pubkey == signers[j]) { + isSigner = true; + break; + } + } + + if (isSigner) { + // Add this operator's weights to the signed stakes + uint256[] storage weights = _operatorInfos[operatorSetKey][cert.referenceTimestamp][uint32(i)].weights; + for (uint256 j = 0; j < weights.length && j < signedStakes.length; j++) { + signedStakes[j] += uint96(weights[j]); + } + } + } + + // After processing, check if all signed stakes are zero + bool anySigned = false; + for (uint256 i = 0; i < signedStakes.length; i++) { + if (signedStakes[i] > 0) { + anySigned = true; + break; + } + } + require(anySigned, VerificationFailed()); + + return signedStakes; + } + + /** + * @notice Parse signatures from the concatenated signature bytes + * @param messageHash The message hash that was signed + * @param signatures The concatenated signatures + * @return signers Array of addresses that signed the message + * @return valid Whether all signatures are valid + */ + function _parseSignatures( + bytes32 messageHash, + bytes memory signatures + ) internal pure returns (address[] memory signers, bool valid) { + // Each ECDSA signature is 65 bytes: r (32 bytes) + s (32 bytes) + v (1 byte) + require(signatures.length % 65 == 0, "Invalid signature length"); + + uint256 signatureCount = signatures.length / 65; + signers = new address[](signatureCount); + + for (uint256 i = 0; i < signatureCount; i++) { + bytes memory signature = new bytes(65); + for (uint256 j = 0; j < 65; j++) { + signature[j] = signatures[i * 65 + j]; + } + + // Recover the signer + address signer = messageHash.recover(signature); + + // If any signature is invalid (returns address(0)), the whole certificate is invalid + if (signer == address(0)) { + return (signers, false); + } + + // Check for duplicate signers + for (uint256 j = 0; j < i; j++) { + if (signers[j] == signer) { + return (signers, false); + } + } + + signers[i] = signer; + } + + return (signers, true); + } + + /** + * @notice Get operator infos for a timestamp + * @param operatorSet The operator set + * @param referenceTimestamp The reference timestamp + * @return The operator infos + */ + function getOperatorInfos( + OperatorSet memory operatorSet, + uint32 referenceTimestamp + ) external view returns (ECDSAOperatorInfo[] memory) { + bytes32 operatorSetKey = operatorSet.key(); + uint32 numOperators = uint32(_numOperators[operatorSetKey][referenceTimestamp]); + ECDSAOperatorInfo[] memory operatorInfos = new ECDSAOperatorInfo[](numOperators); + + for (uint32 i = 0; i < numOperators; i++) { + operatorInfos[i] = _operatorInfos[operatorSetKey][referenceTimestamp][i]; + } + + return operatorInfos; + } + + /** + * @notice Calculate the total stakes for all operators at a given reference timestamp + * @param operatorSet The operator set to calculate stakes for + * @param referenceTimestamp The reference timestamp + * @return totalStakes The total stakes for all operators + */ + function _getTotalStakes( + OperatorSet calldata operatorSet, + uint32 referenceTimestamp + ) internal view returns (uint96[] memory totalStakes) { + bytes32 operatorSetKey = operatorSet.key(); + require(_latestReferenceTimestamps[operatorSetKey] == referenceTimestamp, ReferenceTimestampDoesNotExist()); + uint256 operatorCount = _numOperators[operatorSetKey][referenceTimestamp]; + require(operatorCount > 0, ReferenceTimestampDoesNotExist()); + uint256 stakeTypesCount = _operatorInfos[operatorSetKey][referenceTimestamp][0].weights.length; + totalStakes = new uint96[](stakeTypesCount); + for (uint256 i = 0; i < operatorCount; i++) { + uint256[] storage weights = _operatorInfos[operatorSetKey][referenceTimestamp][uint32(i)].weights; + for (uint256 j = 0; j < weights.length && j < stakeTypesCount; j++) { + totalStakes[j] += uint96(weights[j]); + } + } + return totalStakes; + } +} diff --git a/src/contracts/multichain/ECDSACertificateVerifierStorage.sol b/src/contracts/multichain/ECDSACertificateVerifierStorage.sol new file mode 100644 index 0000000000..582b8ed507 --- /dev/null +++ b/src/contracts/multichain/ECDSACertificateVerifierStorage.sol @@ -0,0 +1,46 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import {OperatorSet} from "../libraries/OperatorSetLib.sol"; +import "../interfaces/IOperatorTableUpdater.sol"; +import "../interfaces/IECDSATableCalculator.sol"; +import "../interfaces/IECDSACertificateVerifier.sol"; +import "../interfaces/IBaseCertificateVerifier.sol"; + +abstract contract ECDSACertificateVerifierStorage is IECDSACertificateVerifier { + // Constants + + /// @dev Basis point unit denominator for division + uint256 internal constant BPS_DENOMINATOR = 10_000; + + // Immutables + + /// @dev The address that can update operator tables + IOperatorTableUpdater public immutable operatorTableUpdater; + + // Mutatables + + /// @dev Mapping from operatorSet key to owner address + mapping(bytes32 => address) internal _operatorSetOwners; + + /// @dev Mapping from operatorSet key to maximum staleness period + mapping(bytes32 => uint32) internal _maxStalenessPeriods; + + /// @dev Mapping from operatorSet key to latest reference timestamp + mapping(bytes32 => uint32) internal _latestReferenceTimestamps; + + /// @dev Mapping from referenceTimestamp to the number of operators + mapping(bytes32 operatorSetKey => mapping(uint32 referenceTimestamp => uint256 numOperators)) internal _numOperators; + + /// @dev Mapping from operatorSetKey to referenceTimestamp to operatorInfos + mapping(bytes32 operatorSetKey => mapping(uint32 referenceTimestamp => mapping(uint32 => ECDSAOperatorInfo))) + internal _operatorInfos; + + // Construction + + constructor( + IOperatorTableUpdater _operatorTableUpdater + ) { + operatorTableUpdater = _operatorTableUpdater; + } +} diff --git a/src/test/unit/ECDSACertificateVerifierUnit.t.sol b/src/test/unit/ECDSACertificateVerifierUnit.t.sol new file mode 100644 index 0000000000..f6ace5cb91 --- /dev/null +++ b/src/test/unit/ECDSACertificateVerifierUnit.t.sol @@ -0,0 +1,514 @@ +// SPDX-License-Identifier: BUSL-1.1 +pragma solidity ^0.8.27; + +import "@openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol"; +import "forge-std/Test.sol"; + +import "src/contracts/libraries/OperatorSetLib.sol"; +import "src/contracts/multichain/ECDSACertificateVerifier.sol"; +import "src/contracts/interfaces/IOperatorTableUpdater.sol"; +import "src/contracts/interfaces/IECDSACertificateVerifier.sol"; +import "src/contracts/interfaces/ICrossChainRegistry.sol"; + +/** + * @title ECDSACertificateVerifierTest + * @notice Unit tests for ECDSACertificateVerifier contract + */ +contract ECDSACertificateVerifierTest is Test { + // Contract being tested + ECDSACertificateVerifier verifier; + + // Test accounts + address owner = address(0x1); + address tableUpdater = address(0x2); + address nonOwner = address(0x3); + address operatorSetOwner = address(0x4); + + // Test data + uint32 numOperators = 4; + uint32 maxStaleness = 3600; // 1 hour max staleness + + // Create an OperatorSet for testing + OperatorSet testOperatorSet; + + // ECDSA signature specific fields + bytes32 msgHash; + uint signerPrivateKey = 0x1234; + address signerAddress; + + // Events + event TableUpdated( + OperatorSet indexed operatorSet, uint32 referenceTimestamp, IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] operatorInfos + ); + + function setUp() public virtual { + vm.warp(1_000_000); // Set block timestamp + + testOperatorSet.avs = address(0x5); + testOperatorSet.id = 1; + + // Deploy implementation + ECDSACertificateVerifier implementation = new ECDSACertificateVerifier(IOperatorTableUpdater(tableUpdater)); + + // Deploy proxy and initialize + ERC1967Proxy proxy = new ERC1967Proxy(address(implementation), ""); + + verifier = ECDSACertificateVerifier(address(proxy)); + + // Set standard test message hash + msgHash = keccak256(abi.encodePacked("test message")); + + // Generate signer address from private key + signerAddress = vm.addr(signerPrivateKey); + } + + // Helper to create operator infos with specified weights + function createOperatorInfos(uint numSigners, uint numNonSigners) + internal + view + returns ( + IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory, + address[] memory, + uint[] memory // signer private keys + ) + { + require(numSigners + numNonSigners == numOperators, "Total operators mismatch"); + + IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory ops = new IECDSACertificateVerifierTypes.ECDSAOperatorInfo[](numOperators); + address[] memory nonSigners = new address[](numNonSigners); + uint[] memory signerPrivKeys = new uint[](numSigners); + + // Create signers + for (uint i = 0; i < numSigners; i++) { + uint privateKey = uint(keccak256(abi.encodePacked("signer", i))); + address pubkey = vm.addr(privateKey); + + ops[i].pubkey = pubkey; + ops[i].weights = new uint[](2); + ops[i].weights[0] = uint(100 + i * 10); + ops[i].weights[1] = uint(200 + i * 20); + signerPrivKeys[i] = privateKey; + } + + // Create non-signers + for (uint i = 0; i < numNonSigners; i++) { + uint idx = numSigners + i; + uint privateKey = uint(keccak256(abi.encodePacked("nonsigner", i))); + address pubkey = vm.addr(privateKey); + + ops[idx].pubkey = pubkey; + ops[idx].weights = new uint[](2); + ops[idx].weights[0] = uint(100 + idx * 10); + ops[idx].weights[1] = uint(200 + idx * 20); + nonSigners[i] = pubkey; + } + + return (ops, nonSigners, signerPrivKeys); + } + + // Helper to create operator set config + function createOperatorSetConfig() internal view returns (ICrossChainRegistryTypes.OperatorSetConfig memory) { + return ICrossChainRegistryTypes.OperatorSetConfig({owner: operatorSetOwner, maxStalenessPeriod: maxStaleness}); + } + + // Helper to create a certificate with real ECDSA signatures + function createCertificate( + uint32 referenceTimestamp, + bytes32 messageHash, + address[] memory nonSigners, + IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory ops, + uint[] memory signerPrivKeys + ) internal view returns (IECDSACertificateVerifierTypes.ECDSACertificate memory) { + // Create EIP-712 compliant message hash + bytes32 structHash = keccak256(abi.encode(verifier.ECDSA_CERTIFICATE_TYPEHASH(), referenceTimestamp, messageHash)); + bytes32 signableDigest = keccak256(abi.encodePacked("\x19\x01", verifier.domainSeparator(), structHash)); + + // Generate signatures only for signers + bytes memory signatures; + uint signerIdx = 0; + for (uint i = 0; i < ops.length; i++) { + bool isNonSigner = false; + for (uint j = 0; j < nonSigners.length; j++) { + if (ops[i].pubkey == nonSigners[j]) { + isNonSigner = true; + break; + } + } + + if (!isNonSigner) { + (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerPrivKeys[signerIdx], signableDigest); + bytes memory signature = abi.encodePacked(r, s, v); + signatures = bytes.concat(signatures, signature); + signerIdx++; + } + } + + return IECDSACertificateVerifierTypes.ECDSACertificate({ + referenceTimestamp: referenceTimestamp, + messageHash: messageHash, + sig: signatures + }); + } + + // Test updating the operator table + function testUpdateOperatorTable() public { + uint32 referenceTimestamp = uint32(block.timestamp); + + // Create operators - 3 signers, 1 non-signer + (IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators, address[] memory nonSigners, uint[] memory signerPrivKeys) = + createOperatorInfos(3, 1); + + // Create operator set config + ICrossChainRegistryTypes.OperatorSetConfig memory operatorSetConfig = createOperatorSetConfig(); + + vm.startPrank(tableUpdater); + + // Update the operator table + verifier.updateOperatorTable(testOperatorSet, referenceTimestamp, operators, operatorSetConfig); + + vm.stopPrank(); + + // Verify storage updates + assertEq(verifier.latestReferenceTimestamp(testOperatorSet), referenceTimestamp, "Reference timestamp not updated correctly"); + assertEq(verifier.getOperatorSetOwner(testOperatorSet), operatorSetOwner, "Operator set owner not stored correctly"); + assertEq(verifier.maxOperatorTableStaleness(testOperatorSet), maxStaleness, "Max staleness not stored correctly"); + + // Verify operator infos were stored correctly + IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory storedOperators = + verifier.getOperatorInfos(testOperatorSet, referenceTimestamp); + + assertEq(storedOperators.length, operators.length, "Number of operators not stored correctly"); + for (uint i = 0; i < operators.length; i++) { + assertEq(storedOperators[i].pubkey, operators[i].pubkey, "Operator pubkey not stored correctly"); + assertEq(storedOperators[i].weights[0], operators[i].weights[0], "Operator weight 0 not stored correctly"); + assertEq(storedOperators[i].weights[1], operators[i].weights[1], "Operator weight 1 not stored correctly"); + } + } + + // Test verifyCertificate with actual ECDSA signature validation + function testVerifyCertificate() public { + uint32 referenceTimestamp = uint32(block.timestamp); + + // Create operators - 3 signers, 1 non-signer + (IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators, address[] memory nonSigners, uint[] memory signerPrivKeys) = + createOperatorInfos(3, 1); + + // Create operator set config + ICrossChainRegistryTypes.OperatorSetConfig memory operatorSetConfig = createOperatorSetConfig(); + + vm.prank(tableUpdater); + verifier.updateOperatorTable(testOperatorSet, referenceTimestamp, operators, operatorSetConfig); + + // Create certificate with real ECDSA signatures + IECDSACertificateVerifierTypes.ECDSACertificate memory cert = + createCertificate(referenceTimestamp, msgHash, nonSigners, operators, signerPrivKeys); + + uint[] memory signedStakes = verifier.verifyCertificate(testOperatorSet, cert); + + // Check that the signed stakes are correct + assertEq(signedStakes.length, 2, "Wrong number of stake types"); + + // Calculate expected signed stakes + uint[] memory expectedSignedStakes = new uint[](2); + + // Start with total stakes + for (uint i = 0; i < operators.length; i++) { + expectedSignedStakes[0] += operators[i].weights[0]; + expectedSignedStakes[1] += operators[i].weights[1]; + } + + // Subtract non-signer stakes + for (uint i = 0; i < nonSigners.length; i++) { + for (uint j = 0; j < operators.length; j++) { + if (operators[j].pubkey == nonSigners[i]) { + expectedSignedStakes[0] -= operators[j].weights[0]; + expectedSignedStakes[1] -= operators[j].weights[1]; + break; + } + } + } + + assertEq(signedStakes[0], expectedSignedStakes[0], "Wrong signed stake for type 0"); + assertEq(signedStakes[1], expectedSignedStakes[1], "Wrong signed stake for type 1"); + } + + // Test verifyCertificateProportion + function testVerifyCertificateProportion() public { + uint32 referenceTimestamp = uint32(block.timestamp); + + // Create operators - 3 signers, 1 non-signer + (IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators, address[] memory nonSigners, uint[] memory signerPrivKeys) = + createOperatorInfos(3, 1); + + // Create operator set config + ICrossChainRegistryTypes.OperatorSetConfig memory operatorSetConfig = createOperatorSetConfig(); + + vm.prank(tableUpdater); + verifier.updateOperatorTable(testOperatorSet, referenceTimestamp, operators, operatorSetConfig); + + // Create certificate with real ECDSA signatures + IECDSACertificateVerifierTypes.ECDSACertificate memory cert = + createCertificate(referenceTimestamp, msgHash, nonSigners, operators, signerPrivKeys); + + // Set thresholds at 60% of total stake for each type + uint16[] memory thresholds = new uint16[](2); + thresholds[0] = 6000; // 60% + thresholds[1] = 6000; // 60% + + // Verify certificate meets thresholds + bool meetsThresholds = verifier.verifyCertificateProportion(testOperatorSet, cert, thresholds); + + // With 3 signers out of 4, should meet 60% threshold + assertTrue(meetsThresholds, "Certificate should meet thresholds"); + + // Try with higher threshold that shouldn't be met + thresholds[0] = 9000; // 90% + thresholds[1] = 9000; // 90% + + meetsThresholds = verifier.verifyCertificateProportion(testOperatorSet, cert, thresholds); + + // Calculate percentage of signed stakes to determine if it should meet threshold + uint[] memory signedStakes = verifier.verifyCertificate(testOperatorSet, cert); + uint totalStake0 = 0; + uint totalStake1 = 0; + for (uint i = 0; i < operators.length; i++) { + totalStake0 += operators[i].weights[0]; + totalStake1 += operators[i].weights[1]; + } + uint signedPercentage0 = (signedStakes[0] * 10_000) / totalStake0; + uint signedPercentage1 = (signedStakes[1] * 10_000) / totalStake1; + + bool shouldMeetThreshold = (signedPercentage0 >= 9000) && (signedPercentage1 >= 9000); + assertEq(meetsThresholds, shouldMeetThreshold, "Certificate threshold check incorrect"); + } + + // Test verifyCertificateNominal + function testVerifyCertificateNominal() public { + uint32 referenceTimestamp = uint32(block.timestamp); + + // Create operators - 3 signers, 1 non-signer + (IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators, address[] memory nonSigners, uint[] memory signerPrivKeys) = + createOperatorInfos(3, 1); + + // Create operator set config + ICrossChainRegistryTypes.OperatorSetConfig memory operatorSetConfig = createOperatorSetConfig(); + + vm.prank(tableUpdater); + verifier.updateOperatorTable(testOperatorSet, referenceTimestamp, operators, operatorSetConfig); + + // Create certificate with real ECDSA signatures + IECDSACertificateVerifierTypes.ECDSACertificate memory cert = + createCertificate(referenceTimestamp, msgHash, nonSigners, operators, signerPrivKeys); + + // Get the signed stakes first + uint[] memory signedStakes = verifier.verifyCertificate(testOperatorSet, cert); + + // Test with thresholds lower than signed stakes (should pass) + uint[] memory passThresholds = new uint[](2); + passThresholds[0] = signedStakes[0] - 10; + passThresholds[1] = signedStakes[1] - 10; + + bool meetsThresholds = verifier.verifyCertificateNominal(testOperatorSet, cert, passThresholds); + assertTrue(meetsThresholds, "Certificate should meet nominal thresholds"); + + // Test with thresholds higher than signed stakes (should fail) + uint[] memory failThresholds = new uint[](2); + failThresholds[0] = signedStakes[0] + 10; + failThresholds[1] = signedStakes[1] + 10; + + meetsThresholds = verifier.verifyCertificateNominal(testOperatorSet, cert, failThresholds); + assertFalse(meetsThresholds, "Certificate should not meet impossible nominal thresholds"); + } + + // Test with invalid signature (wrong message hash) + function testVerifyCertificateInvalidSignature() public { + uint32 referenceTimestamp = uint32(block.timestamp); + + // Create operators - 3 signers, 1 non-signer + (IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators, address[] memory nonSigners, uint[] memory signerPrivKeys) = + createOperatorInfos(3, 1); + + // Create operator set config + ICrossChainRegistryTypes.OperatorSetConfig memory operatorSetConfig = createOperatorSetConfig(); + + vm.prank(tableUpdater); + verifier.updateOperatorTable(testOperatorSet, referenceTimestamp, operators, operatorSetConfig); + + // Create a certificate with signatures for the original message hash + bytes32 originalHash = msgHash; + IECDSACertificateVerifierTypes.ECDSACertificate memory cert = + createCertificate(referenceTimestamp, originalHash, nonSigners, operators, signerPrivKeys); + + // Now modify the certificate to use a different message hash + // This should make the signatures invalid since they were created for originalHash + bytes32 differentHash = keccak256("different message"); + cert.messageHash = differentHash; + + // Verification should fail because the signatures were created for originalHash + // but we're trying to verify them against differentHash + vm.expectRevert(abi.encodeWithSignature("VerificationFailed()")); + verifier.verifyCertificate(testOperatorSet, cert); + } + + // Test certificate with stale timestamp (should fail) + function testVerifyCertificateStaleTimestamp() public { + uint32 referenceTimestamp = uint32(block.timestamp); + + // Create operators - 3 signers, 1 non-signer + (IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators, address[] memory nonSigners, uint[] memory signerPrivKeys) = + createOperatorInfos(3, 1); + + // Create operator set config + ICrossChainRegistryTypes.OperatorSetConfig memory operatorSetConfig = createOperatorSetConfig(); + + vm.prank(tableUpdater); + verifier.updateOperatorTable(testOperatorSet, referenceTimestamp, operators, operatorSetConfig); + + // Create certificate with real ECDSA signatures + IECDSACertificateVerifierTypes.ECDSACertificate memory cert = + createCertificate(referenceTimestamp, msgHash, nonSigners, operators, signerPrivKeys); + + // Jump forward in time beyond the max staleness + vm.warp(block.timestamp + maxStaleness + 1); + + // Verification should fail due to staleness + vm.expectRevert(abi.encodeWithSignature("CertificateStale()")); + verifier.verifyCertificate(testOperatorSet, cert); + } + + // Test with invalid reference timestamp + function testInvalidReferenceTimestamp() public { + uint32 existingReferenceTimestamp = uint32(block.timestamp); + uint32 nonExistentTimestamp = existingReferenceTimestamp + 1000; + + // Create operators - 3 signers, 1 non-signer + (IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators, address[] memory nonSigners, uint[] memory signerPrivKeys) = + createOperatorInfos(3, 1); + + // Create operator set config + ICrossChainRegistryTypes.OperatorSetConfig memory operatorSetConfig = createOperatorSetConfig(); + + vm.prank(tableUpdater); + verifier.updateOperatorTable(testOperatorSet, existingReferenceTimestamp, operators, operatorSetConfig); + + // Create certificate using a non-existent timestamp + IECDSACertificateVerifierTypes.ECDSACertificate memory cert = + createCertificate(nonExistentTimestamp, msgHash, nonSigners, operators, signerPrivKeys); + + // Verification should fail due to timestamp not existing + vm.expectRevert(abi.encodeWithSignature("ReferenceTimestampDoesNotExist()")); + verifier.verifyCertificate(testOperatorSet, cert); + } + + // Test multiple operator sets + function testMultipleOperatorSets() public { + // Create two different operator sets + OperatorSet memory operatorSet1 = OperatorSet({avs: address(0x10), id: 1}); + OperatorSet memory operatorSet2 = OperatorSet({avs: address(0x20), id: 2}); + + uint32 referenceTimestamp = uint32(block.timestamp); + + // Create different operators for each set + (IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators1, address[] memory nonSigners1, uint[] memory signerPrivKeys1) + = createOperatorInfos(3, 1); + + // Create second set of operators with different private keys + IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators2 = new IECDSACertificateVerifierTypes.ECDSAOperatorInfo[](4); + address[] memory nonSigners2 = new address[](2); + uint[] memory signerPrivKeys2 = new uint[](2); + + for (uint i = 0; i < 4; i++) { + uint privateKey = uint(keccak256(abi.encodePacked("set2_signer", i))); + address pubkey = vm.addr(privateKey); + + operators2[i].pubkey = pubkey; + operators2[i].weights = new uint[](2); + operators2[i].weights[0] = uint(100 + i * 10); + operators2[i].weights[1] = uint(200 + i * 20); + + if (i >= 2) signerPrivKeys2[i - 2] = privateKey; + else nonSigners2[i] = pubkey; + } + + // Create operator set configs with different owners + ICrossChainRegistryTypes.OperatorSetConfig memory config1 = ICrossChainRegistryTypes.OperatorSetConfig({ + owner: address(0x100), + maxStalenessPeriod: 1800 // 30 minutes + }); + ICrossChainRegistryTypes.OperatorSetConfig memory config2 = ICrossChainRegistryTypes.OperatorSetConfig({ + owner: address(0x200), + maxStalenessPeriod: 7200 // 2 hours + }); + + vm.startPrank(tableUpdater); + + // Update both operator tables + verifier.updateOperatorTable(operatorSet1, referenceTimestamp, operators1, config1); + verifier.updateOperatorTable(operatorSet2, referenceTimestamp, operators2, config2); + + vm.stopPrank(); + + // Verify that both operator sets are stored correctly and independently + assertEq(verifier.getOperatorSetOwner(operatorSet1), address(0x100), "OperatorSet1 owner incorrect"); + assertEq(verifier.getOperatorSetOwner(operatorSet2), address(0x200), "OperatorSet2 owner incorrect"); + + assertEq(verifier.maxOperatorTableStaleness(operatorSet1), 1800, "OperatorSet1 staleness incorrect"); + assertEq(verifier.maxOperatorTableStaleness(operatorSet2), 7200, "OperatorSet2 staleness incorrect"); + + assertEq(verifier.latestReferenceTimestamp(operatorSet1), referenceTimestamp, "OperatorSet1 timestamp incorrect"); + assertEq(verifier.latestReferenceTimestamp(operatorSet2), referenceTimestamp, "OperatorSet2 timestamp incorrect"); + + // Verify operator infos are stored independently + IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory storedOps1 = verifier.getOperatorInfos(operatorSet1, referenceTimestamp); + IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory storedOps2 = verifier.getOperatorInfos(operatorSet2, referenceTimestamp); + + assertEq(storedOps1.length, 4, "OperatorSet1 should have 4 operators"); + assertEq(storedOps2.length, 4, "OperatorSet2 should have 4 operators"); + + // Verify they have different operators + assertTrue(storedOps1[0].pubkey != storedOps2[0].pubkey, "Operators should be different"); + } + + // Test access control for operator table updates + function testOperatorTableUpdateAccessControl() public { + uint32 referenceTimestamp = uint32(block.timestamp); + + // Create operators + (IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators, address[] memory nonSigners, uint[] memory signerPrivKeys) = + createOperatorInfos(3, 1); + + ICrossChainRegistryTypes.OperatorSetConfig memory operatorSetConfig = createOperatorSetConfig(); + + // Try to update with non-authorized account + vm.prank(nonOwner); + vm.expectRevert(abi.encodeWithSignature("OnlyTableUpdater()")); + verifier.updateOperatorTable(testOperatorSet, referenceTimestamp, operators, operatorSetConfig); + + // Should succeed with authorized account + vm.prank(tableUpdater); + verifier.updateOperatorTable(testOperatorSet, referenceTimestamp, operators, operatorSetConfig); + } + + // Test stale table update (timestamp not increasing) + function testStaleTableUpdate() public { + uint32 firstTimestamp = uint32(block.timestamp); + uint32 staleTimestamp = firstTimestamp - 100; // Earlier timestamp + + // Create operators + (IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory operators, address[] memory nonSigners, uint[] memory signerPrivKeys) = + createOperatorInfos(3, 1); + + ICrossChainRegistryTypes.OperatorSetConfig memory operatorSetConfig = createOperatorSetConfig(); + + vm.startPrank(tableUpdater); + + // First update should succeed + verifier.updateOperatorTable(testOperatorSet, firstTimestamp, operators, operatorSetConfig); + + // Second update with earlier timestamp should fail + vm.expectRevert(abi.encodeWithSignature("TableUpdateStale()")); + verifier.updateOperatorTable(testOperatorSet, staleTimestamp, operators, operatorSetConfig); + + vm.stopPrank(); + } +} From 3895795d76834e8f17a1e3082f363f07c48a6aac Mon Sep 17 00:00:00 2001 From: Michael Date: Mon, 16 Jun 2025 12:22:24 -0400 Subject: [PATCH 2/5] chore: cleanup --- .../interfaces/IECDSACertificateVerifier.sol | 4 ++++ .../multichain/ECDSACertificateVerifier.sol | 14 ++------------ 2 files changed, 6 insertions(+), 12 deletions(-) diff --git a/src/contracts/interfaces/IECDSACertificateVerifier.sol b/src/contracts/interfaces/IECDSACertificateVerifier.sol index 65990d3dd9..f40bb211fe 100644 --- a/src/contracts/interfaces/IECDSACertificateVerifier.sol +++ b/src/contracts/interfaces/IECDSACertificateVerifier.sol @@ -6,6 +6,10 @@ import "./IBaseCertificateVerifier.sol"; import "./IECDSATableCalculator.sol"; interface IECDSACertificateVerifierTypes is IECDSATableCalculatorTypes { + + // Errors + error InvalidSignatureLength(); + /** * @notice A ECDSA Certificate * @param referenceTimestamp the timestamp at which the certificate was created diff --git a/src/contracts/multichain/ECDSACertificateVerifier.sol b/src/contracts/multichain/ECDSACertificateVerifier.sol index 4bb99b72e4..81f4f54e4e 100644 --- a/src/contracts/multichain/ECDSACertificateVerifier.sol +++ b/src/contracts/multichain/ECDSACertificateVerifier.sol @@ -20,16 +20,6 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor bytes32 public constant ECDSA_CERTIFICATE_TYPEHASH = keccak256("ECDSACertificate(uint32 referenceTimestamp,bytes32 messageHash)"); - /** - * @notice Struct to hold verification context and reduce stack depth - */ - struct VerificationContext { - bytes32 operatorSetKey; - ECDSAOperatorInfo[] operatorInfos; - uint256[] signedStakes; - address[] nonSigners; - } - /** * @notice Restricts access to the operator table updater */ @@ -150,7 +140,7 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor for (uint256 i = 0; i < signedStakes96.length; i++) { signedStakes[i] = uint256(signedStakes96[i]); } - require(signedStakes.length == totalStakeNominalThresholds.length, "Length mismatch"); + if (signedStakes.length != totalStakeNominalThresholds.length) revert ArrayLengthMismatch(); for (uint256 i = 0; i < signedStakes.length; i++) { if (signedStakes[i] < totalStakeNominalThresholds[i]) { return false; @@ -236,7 +226,7 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor bytes memory signatures ) internal pure returns (address[] memory signers, bool valid) { // Each ECDSA signature is 65 bytes: r (32 bytes) + s (32 bytes) + v (1 byte) - require(signatures.length % 65 == 0, "Invalid signature length"); + if (signatures.length % 65 != 0) revert InvalidSignatureLength(); uint256 signatureCount = signatures.length / 65; signers = new address[](signatureCount); From cc9065348ac523ee88b38afffb7e613bfef015af Mon Sep 17 00:00:00 2001 From: Michael Date: Mon, 16 Jun 2025 14:06:47 -0400 Subject: [PATCH 3/5] refactor: pr comments --- .../interfaces/IECDSACertificateVerifier.sol | 1 - .../multichain/ECDSACertificateVerifier.sol | 167 +++++++++--------- .../ECDSACertificateVerifierStorage.sol | 8 + .../unit/ECDSACertificateVerifierUnit.t.sol | 43 ++++- 4 files changed, 129 insertions(+), 90 deletions(-) diff --git a/src/contracts/interfaces/IECDSACertificateVerifier.sol b/src/contracts/interfaces/IECDSACertificateVerifier.sol index f40bb211fe..e153fff540 100644 --- a/src/contracts/interfaces/IECDSACertificateVerifier.sol +++ b/src/contracts/interfaces/IECDSACertificateVerifier.sol @@ -6,7 +6,6 @@ import "./IBaseCertificateVerifier.sol"; import "./IECDSATableCalculator.sol"; interface IECDSACertificateVerifierTypes is IECDSATableCalculatorTypes { - // Errors error InvalidSignatureLength(); diff --git a/src/contracts/multichain/ECDSACertificateVerifier.sol b/src/contracts/multichain/ECDSACertificateVerifier.sol index 81f4f54e4e..198099a2c4 100644 --- a/src/contracts/multichain/ECDSACertificateVerifier.sol +++ b/src/contracts/multichain/ECDSACertificateVerifier.sol @@ -16,10 +16,6 @@ import "./ECDSACertificateVerifierStorage.sol"; contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStorage, SignatureUtilsMixin { using ECDSA for bytes32; - // EIP-712 type hash for certificate verification - bytes32 public constant ECDSA_CERTIFICATE_TYPEHASH = - keccak256("ECDSACertificate(uint32 referenceTimestamp,bytes32 messageHash)"); - /** * @notice Restricts access to the operator table updater */ @@ -32,13 +28,43 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor * @notice Constructor for the certificate verifier * @dev Disables initializers to prevent implementation initialization * @param _operatorTableUpdater Address authorized to update operator tables + * @param _version The version string for the SignatureUtilsMixin */ constructor( - IOperatorTableUpdater _operatorTableUpdater - ) ECDSACertificateVerifierStorage(_operatorTableUpdater) SignatureUtilsMixin("1.0.0") { + IOperatorTableUpdater _operatorTableUpdater, + string memory _version + ) ECDSACertificateVerifierStorage(_operatorTableUpdater) SignatureUtilsMixin(_version) { _disableInitializers(); } + /** + * @notice Override domainSeparator to not include chainId + * @return The domain separator hash without chainId + */ + function domainSeparator() public view override returns (bytes32) { + return keccak256( + abi.encode( + EIP712_DOMAIN_TYPEHASH_NO_CHAINID, + keccak256(bytes("EigenLayer")), + keccak256(bytes(_majorVersion())), + address(this) + ) + ); + } + + /** + * @notice Calculate the EIP-712 digest for a certificate + * @param referenceTimestamp The reference timestamp + * @param messageHash The message hash + * @return The EIP-712 digest + * @dev This function is public to allow offchain tools to calculate the same digest + * @dev Note: This does not support smart contract based signatures for multichain + */ + function calculateCertificateDigest(uint32 referenceTimestamp, bytes32 messageHash) public view returns (bytes32) { + bytes32 structHash = keccak256(abi.encode(ECDSA_CERTIFICATE_TYPEHASH, referenceTimestamp, messageHash)); + return _calculateSignableDigest(structHash); + } + ///@inheritdoc IBaseCertificateVerifier function getOperatorSetOwner( OperatorSet memory operatorSet @@ -90,65 +116,6 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor emit TableUpdated(operatorSet, referenceTimestamp, operatorInfos); } - ///@inheritdoc IECDSACertificateVerifier - function verifyCertificate( - OperatorSet calldata operatorSet, - ECDSACertificate calldata cert - ) external view returns (uint256[] memory) { - uint96[] memory signedStakes96 = _verifyECDSACertificate(operatorSet, cert); - uint256[] memory signedStakes = new uint256[](signedStakes96.length); - for (uint256 i = 0; i < signedStakes96.length; i++) { - signedStakes[i] = uint256(signedStakes96[i]); - } - return signedStakes; - } - - ///@inheritdoc IECDSACertificateVerifier - function verifyCertificateProportion( - OperatorSet calldata operatorSet, - ECDSACertificate calldata cert, - uint16[] calldata totalStakeProportionThresholds - ) external view returns (bool) { - uint96[] memory signedStakes96 = _verifyECDSACertificate(operatorSet, cert); - uint256[] memory signedStakes = new uint256[](signedStakes96.length); - for (uint256 i = 0; i < signedStakes96.length; i++) { - signedStakes[i] = uint256(signedStakes96[i]); - } - uint96[] memory totalStakes96 = _getTotalStakes(operatorSet, cert.referenceTimestamp); - uint256[] memory totalStakes = new uint256[](totalStakes96.length); - for (uint256 i = 0; i < totalStakes96.length; i++) { - totalStakes[i] = uint256(totalStakes96[i]); - } - require(signedStakes.length == totalStakeProportionThresholds.length, ArrayLengthMismatch()); - for (uint256 i = 0; i < signedStakes.length; i++) { - uint256 threshold = (totalStakes[i] * totalStakeProportionThresholds[i]) / 10_000; - if (signedStakes[i] < threshold) { - return false; - } - } - return true; - } - - ///@inheritdoc IECDSACertificateVerifier - function verifyCertificateNominal( - OperatorSet calldata operatorSet, - ECDSACertificate calldata cert, - uint256[] memory totalStakeNominalThresholds - ) external view returns (bool) { - uint96[] memory signedStakes96 = _verifyECDSACertificate(operatorSet, cert); - uint256[] memory signedStakes = new uint256[](signedStakes96.length); - for (uint256 i = 0; i < signedStakes96.length; i++) { - signedStakes[i] = uint256(signedStakes96[i]); - } - if (signedStakes.length != totalStakeNominalThresholds.length) revert ArrayLengthMismatch(); - for (uint256 i = 0; i < signedStakes.length; i++) { - if (signedStakes[i] < totalStakeNominalThresholds[i]) { - return false; - } - } - return true; - } - /** * @notice Internal function to verify a certificate * @param cert The certificate to verify @@ -157,7 +124,7 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor function _verifyECDSACertificate( OperatorSet calldata operatorSet, ECDSACertificate calldata cert - ) internal view returns (uint96[] memory) { + ) internal view returns (uint256[] memory) { bytes32 operatorSetKey = operatorSet.key(); // Assert that reference timestamp is not stale @@ -167,13 +134,11 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor require(_latestReferenceTimestamps[operatorSetKey] == cert.referenceTimestamp, ReferenceTimestampDoesNotExist()); // Get the total stakes - uint96[] memory totalStakes = _getTotalStakes(operatorSet, cert.referenceTimestamp); - uint96[] memory signedStakes = new uint96[](totalStakes.length); + uint256[] memory totalStakes = _getTotalStakes(operatorSet, cert.referenceTimestamp); + uint256[] memory signedStakes = new uint256[](totalStakes.length); // Compute the EIP-712 digest for signature recovery - bytes32 structHash = - keccak256(abi.encode(ECDSA_CERTIFICATE_TYPEHASH, cert.referenceTimestamp, cert.messageHash)); - bytes32 signableDigest = keccak256(abi.encodePacked("\x19\x01", domainSeparator(), structHash)); + bytes32 signableDigest = calculateCertificateDigest(cert.referenceTimestamp, cert.messageHash); // Parse the signatures (address[] memory signers, bool validSignatures) = _parseSignatures(signableDigest, cert.sig); @@ -196,7 +161,7 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor // Add this operator's weights to the signed stakes uint256[] storage weights = _operatorInfos[operatorSetKey][cert.referenceTimestamp][uint32(i)].weights; for (uint256 j = 0; j < weights.length && j < signedStakes.length; j++) { - signedStakes[j] += uint96(weights[j]); + signedStakes[j] += weights[j]; } } } @@ -214,12 +179,56 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor return signedStakes; } + ///@inheritdoc IECDSACertificateVerifier + function verifyCertificate( + OperatorSet calldata operatorSet, + ECDSACertificate calldata cert + ) external view returns (uint256[] memory) { + return _verifyECDSACertificate(operatorSet, cert); + } + + ///@inheritdoc IECDSACertificateVerifier + function verifyCertificateProportion( + OperatorSet calldata operatorSet, + ECDSACertificate calldata cert, + uint16[] calldata totalStakeProportionThresholds + ) external view returns (bool) { + uint256[] memory signedStakes = _verifyECDSACertificate(operatorSet, cert); + uint256[] memory totalStakes = _getTotalStakes(operatorSet, cert.referenceTimestamp); + require(signedStakes.length == totalStakeProportionThresholds.length, ArrayLengthMismatch()); + for (uint256 i = 0; i < signedStakes.length; i++) { + uint256 threshold = (totalStakes[i] * totalStakeProportionThresholds[i]) / 10_000; + if (signedStakes[i] < threshold) { + return false; + } + } + return true; + } + + ///@inheritdoc IECDSACertificateVerifier + function verifyCertificateNominal( + OperatorSet calldata operatorSet, + ECDSACertificate calldata cert, + uint256[] memory totalStakeNominalThresholds + ) external view returns (bool) { + uint256[] memory signedStakes = _verifyECDSACertificate(operatorSet, cert); + if (signedStakes.length != totalStakeNominalThresholds.length) revert ArrayLengthMismatch(); + for (uint256 i = 0; i < signedStakes.length; i++) { + if (signedStakes[i] < totalStakeNominalThresholds[i]) { + return false; + } + } + return true; + } + /** * @notice Parse signatures from the concatenated signature bytes * @param messageHash The message hash that was signed * @param signatures The concatenated signatures * @return signers Array of addresses that signed the message * @return valid Whether all signatures are valid + * @dev Signatures must be ordered by signer address (ascending) + * @dev This does not support smart contract based signatures for multichain */ function _parseSignatures( bytes32 messageHash, @@ -245,11 +254,9 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor return (signers, false); } - // Check for duplicate signers - for (uint256 j = 0; j < i; j++) { - if (signers[j] == signer) { - return (signers, false); - } + // Check that signatures are ordered by signer address + if (i > 0 && signer <= signers[i - 1]) { + return (signers, false); } signers[i] = signer; @@ -288,17 +295,17 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor function _getTotalStakes( OperatorSet calldata operatorSet, uint32 referenceTimestamp - ) internal view returns (uint96[] memory totalStakes) { + ) internal view returns (uint256[] memory totalStakes) { bytes32 operatorSetKey = operatorSet.key(); require(_latestReferenceTimestamps[operatorSetKey] == referenceTimestamp, ReferenceTimestampDoesNotExist()); uint256 operatorCount = _numOperators[operatorSetKey][referenceTimestamp]; require(operatorCount > 0, ReferenceTimestampDoesNotExist()); uint256 stakeTypesCount = _operatorInfos[operatorSetKey][referenceTimestamp][0].weights.length; - totalStakes = new uint96[](stakeTypesCount); + totalStakes = new uint256[](stakeTypesCount); for (uint256 i = 0; i < operatorCount; i++) { uint256[] storage weights = _operatorInfos[operatorSetKey][referenceTimestamp][uint32(i)].weights; for (uint256 j = 0; j < weights.length && j < stakeTypesCount; j++) { - totalStakes[j] += uint96(weights[j]); + totalStakes[j] += weights[j]; } } return totalStakes; diff --git a/src/contracts/multichain/ECDSACertificateVerifierStorage.sol b/src/contracts/multichain/ECDSACertificateVerifierStorage.sol index 582b8ed507..daa2bc21f5 100644 --- a/src/contracts/multichain/ECDSACertificateVerifierStorage.sol +++ b/src/contracts/multichain/ECDSACertificateVerifierStorage.sol @@ -13,6 +13,14 @@ abstract contract ECDSACertificateVerifierStorage is IECDSACertificateVerifier { /// @dev Basis point unit denominator for division uint256 internal constant BPS_DENOMINATOR = 10_000; + /// @dev EIP-712 type hash for certificate verification + bytes32 internal constant ECDSA_CERTIFICATE_TYPEHASH = + keccak256("ECDSACertificate(uint32 referenceTimestamp,bytes32 messageHash)"); + + /// @dev The EIP-712 domain type hash used for computing the domain separator without chainId + bytes32 internal constant EIP712_DOMAIN_TYPEHASH_NO_CHAINID = + keccak256("EIP712Domain(string name,string version,address verifyingContract)"); + // Immutables /// @dev The address that can update operator tables diff --git a/src/test/unit/ECDSACertificateVerifierUnit.t.sol b/src/test/unit/ECDSACertificateVerifierUnit.t.sol index f6ace5cb91..b2f7e6f257 100644 --- a/src/test/unit/ECDSACertificateVerifierUnit.t.sol +++ b/src/test/unit/ECDSACertificateVerifierUnit.t.sol @@ -48,7 +48,7 @@ contract ECDSACertificateVerifierTest is Test { testOperatorSet.id = 1; // Deploy implementation - ECDSACertificateVerifier implementation = new ECDSACertificateVerifier(IOperatorTableUpdater(tableUpdater)); + ECDSACertificateVerifier implementation = new ECDSACertificateVerifier(IOperatorTableUpdater(tableUpdater), "1.0.0"); // Deploy proxy and initialize ERC1967Proxy proxy = new ERC1967Proxy(address(implementation), ""); @@ -111,6 +111,11 @@ contract ECDSACertificateVerifierTest is Test { return ICrossChainRegistryTypes.OperatorSetConfig({owner: operatorSetOwner, maxStalenessPeriod: maxStaleness}); } + // Helper function to mirror _calculateSignableDigest + function calculateSignableDigest(bytes32 structHash) internal view returns (bytes32) { + return keccak256(abi.encodePacked("\x19\x01", verifier.domainSeparator(), structHash)); + } + // Helper to create a certificate with real ECDSA signatures function createCertificate( uint32 referenceTimestamp, @@ -119,12 +124,13 @@ contract ECDSACertificateVerifierTest is Test { IECDSACertificateVerifierTypes.ECDSAOperatorInfo[] memory ops, uint[] memory signerPrivKeys ) internal view returns (IECDSACertificateVerifierTypes.ECDSACertificate memory) { - // Create EIP-712 compliant message hash - bytes32 structHash = keccak256(abi.encode(verifier.ECDSA_CERTIFICATE_TYPEHASH(), referenceTimestamp, messageHash)); - bytes32 signableDigest = keccak256(abi.encodePacked("\x19\x01", verifier.domainSeparator(), structHash)); + // Use the contract's digest calculation + bytes32 signableDigest = verifier.calculateCertificateDigest(referenceTimestamp, messageHash); - // Generate signatures only for signers - bytes memory signatures; + // Collect signers and their private keys + uint numSigners = signerPrivKeys.length; + address[] memory signerAddresses = new address[](numSigners); + bytes[] memory signaturesArr = new bytes[](numSigners); uint signerIdx = 0; for (uint i = 0; i < ops.length; i++) { bool isNonSigner = false; @@ -134,15 +140,34 @@ contract ECDSACertificateVerifierTest is Test { break; } } - if (!isNonSigner) { (uint8 v, bytes32 r, bytes32 s) = vm.sign(signerPrivKeys[signerIdx], signableDigest); bytes memory signature = abi.encodePacked(r, s, v); - signatures = bytes.concat(signatures, signature); + signerAddresses[signerIdx] = ops[i].pubkey; + signaturesArr[signerIdx] = signature; signerIdx++; } } - + // Sort signers and signatures by address (ascending) + for (uint i = 0; i < numSigners; i++) { + for (uint j = i + 1; j < numSigners; j++) { + if (signerAddresses[j] < signerAddresses[i]) { + // Swap addresses + address tmpAddr = signerAddresses[i]; + signerAddresses[i] = signerAddresses[j]; + signerAddresses[j] = tmpAddr; + // Swap signatures + bytes memory tmpSig = signaturesArr[i]; + signaturesArr[i] = signaturesArr[j]; + signaturesArr[j] = tmpSig; + } + } + } + // Concatenate signatures in sorted order + bytes memory signatures; + for (uint i = 0; i < numSigners; i++) { + signatures = bytes.concat(signatures, signaturesArr[i]); + } return IECDSACertificateVerifierTypes.ECDSACertificate({ referenceTimestamp: referenceTimestamp, messageHash: messageHash, From 3f2fd1db2dae0d7cea15f4e2329b6eb0bbdd248e Mon Sep 17 00:00:00 2001 From: Michael Date: Mon, 16 Jun 2025 15:38:12 -0400 Subject: [PATCH 4/5] refactor: change loop ordering for clarity --- .../multichain/ECDSACertificateVerifier.sol | 59 +++++++++---------- 1 file changed, 28 insertions(+), 31 deletions(-) diff --git a/src/contracts/multichain/ECDSACertificateVerifier.sol b/src/contracts/multichain/ECDSACertificateVerifier.sol index 198099a2c4..b1c4b9afc3 100644 --- a/src/contracts/multichain/ECDSACertificateVerifier.sol +++ b/src/contracts/multichain/ECDSACertificateVerifier.sol @@ -142,39 +142,35 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor // Parse the signatures (address[] memory signers, bool validSignatures) = _parseSignatures(signableDigest, cert.sig); - require(validSignatures, VerificationFailed()); - // Process each operator to check if they signed - uint256 operatorCount = _numOperators[operatorSetKey][cert.referenceTimestamp]; - for (uint256 i = 0; i < operatorCount; i++) { - // Check if this operator is in the signers list - bool isSigner = false; - for (uint256 j = 0; j < signers.length; j++) { - if (_operatorInfos[operatorSetKey][cert.referenceTimestamp][uint32(i)].pubkey == signers[j]) { - isSigner = true; + // Process each recovered signer + for (uint256 i = 0; i < signers.length; i++) { + address signer = signers[i]; + + // Check if this signer is an operator + bool isOperator = false; + ECDSAOperatorInfo memory operatorInfo; + + for (uint256 j = 0; j < _numOperators[operatorSetKey][cert.referenceTimestamp]; j++) { + operatorInfo = _operatorInfos[operatorSetKey][cert.referenceTimestamp][uint32(j)]; + if (operatorInfo.pubkey == signer) { + isOperator = true; break; } } - if (isSigner) { - // Add this operator's weights to the signed stakes - uint256[] storage weights = _operatorInfos[operatorSetKey][cert.referenceTimestamp][uint32(i)].weights; - for (uint256 j = 0; j < weights.length && j < signedStakes.length; j++) { - signedStakes[j] += weights[j]; - } + // If not an operator, the certificate is invalid + if (!isOperator) { + revert VerificationFailed(); } - } - // After processing, check if all signed stakes are zero - bool anySigned = false; - for (uint256 i = 0; i < signedStakes.length; i++) { - if (signedStakes[i] > 0) { - anySigned = true; - break; + // Add this operator's weights to the signed stakes + uint256[] memory weights = operatorInfo.weights; + for (uint256 j = 0; j < weights.length && j < signedStakes.length; j++) { + signedStakes[j] += weights[j]; } } - require(anySigned, VerificationFailed()); return signedStakes; } @@ -233,7 +229,7 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor function _parseSignatures( bytes32 messageHash, bytes memory signatures - ) internal pure returns (address[] memory signers, bool valid) { + ) internal view returns (address[] memory signers, bool valid) { // Each ECDSA signature is 65 bytes: r (32 bytes) + s (32 bytes) + v (1 byte) if (signatures.length % 65 != 0) revert InvalidSignatureLength(); @@ -247,19 +243,20 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor } // Recover the signer - address signer = messageHash.recover(signature); - - // If any signature is invalid (returns address(0)), the whole certificate is invalid - if (signer == address(0)) { + (address recovered, ECDSA.RecoverError error) = ECDSA.tryRecover(messageHash, signature); + if (error != ECDSA.RecoverError.NoError || recovered == address(0)) { return (signers, false); } // Check that signatures are ordered by signer address - if (i > 0 && signer <= signers[i - 1]) { + if (i > 0 && recovered <= signers[i - 1]) { return (signers, false); } - signers[i] = signer; + // Verify that the recovered address actually signed the message + _checkIsValidSignatureNow(recovered, messageHash, signature, type(uint256).max); + + signers[i] = recovered; } return (signers, true); @@ -303,7 +300,7 @@ contract ECDSACertificateVerifier is Initializable, ECDSACertificateVerifierStor uint256 stakeTypesCount = _operatorInfos[operatorSetKey][referenceTimestamp][0].weights.length; totalStakes = new uint256[](stakeTypesCount); for (uint256 i = 0; i < operatorCount; i++) { - uint256[] storage weights = _operatorInfos[operatorSetKey][referenceTimestamp][uint32(i)].weights; + uint256[] memory weights = _operatorInfos[operatorSetKey][referenceTimestamp][uint32(i)].weights; for (uint256 j = 0; j < weights.length && j < stakeTypesCount; j++) { totalStakes[j] += weights[j]; } From 9e21b261160b0c3bc6faf94f6ec81867ac4039d2 Mon Sep 17 00:00:00 2001 From: Michael Date: Mon, 16 Jun 2025 20:04:42 -0400 Subject: [PATCH 5/5] chore: bindings --- .../BN254CertificateVerifier/binding.go | 2 +- .../ECDSACertificateVerifier/binding.go | 1130 +++++++++++++++++ .../binding.go | 820 ++++++++++++ .../IECDSACertificateVerifier/binding.go | 2 +- pkg/bindings/IOperatorTableUpdater/binding.go | 2 +- pkg/bindings/OperatorTableUpdater/binding.go | 4 +- .../OperatorTableUpdaterStorage/binding.go | 2 +- 7 files changed, 1956 insertions(+), 6 deletions(-) create mode 100644 pkg/bindings/ECDSACertificateVerifier/binding.go create mode 100644 pkg/bindings/ECDSACertificateVerifierStorage/binding.go diff --git a/pkg/bindings/BN254CertificateVerifier/binding.go b/pkg/bindings/BN254CertificateVerifier/binding.go index 6fec5fc86a..b55893ef31 100644 --- a/pkg/bindings/BN254CertificateVerifier/binding.go +++ b/pkg/bindings/BN254CertificateVerifier/binding.go @@ -86,7 +86,7 @@ type OperatorSet struct { // BN254CertificateVerifierMetaData contains all meta data concerning the BN254CertificateVerifier contract. var BN254CertificateVerifierMetaData = &bind.MetaData{ ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_operatorTableUpdater\",\"type\":\"address\",\"internalType\":\"contractIOperatorTableUpdater\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getOperatorInfo\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorIndex\",\"type\":\"uint256\",\"internalType\":\"uint256\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorInfo\",\"components\":[{\"name\":\"pubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetInfo\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorSetInfo\",\"components\":[{\"name\":\"operatorInfoTreeRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"numOperators\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"aggregatePubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"totalWeights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetOwner\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"latestReferenceTimestamp\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maxOperatorTableStaleness\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorTableUpdater\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIOperatorTableUpdater\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setMaxStalenessPeriod\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorSetInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorSetInfo\",\"components\":[{\"name\":\"operatorInfoTreeRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"numOperators\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"aggregatePubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"totalWeights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"operatorSetConfig\",\"type\":\"tuple\",\"internalType\":\"structICrossChainRegistryTypes.OperatorSetConfig\",\"components\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificate\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254Certificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"apk\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"nonSignerWitnesses\",\"type\":\"tuple[]\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254OperatorInfoWitness[]\",\"components\":[{\"name\":\"operatorIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfoProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorInfo\",\"components\":[{\"name\":\"pubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}]}]}],\"outputs\":[{\"name\":\"signedStakes\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificateNominal\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254Certificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"apk\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"nonSignerWitnesses\",\"type\":\"tuple[]\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254OperatorInfoWitness[]\",\"components\":[{\"name\":\"operatorIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfoProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorInfo\",\"components\":[{\"name\":\"pubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}]}]},{\"name\":\"totalStakeNominalThresholds\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificateProportion\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254Certificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"apk\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"nonSignerWitnesses\",\"type\":\"tuple[]\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254OperatorInfoWitness[]\",\"components\":[{\"name\":\"operatorIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfoProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorInfo\",\"components\":[{\"name\":\"pubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}]}]},{\"name\":\"totalStakeProportionThresholds\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MaxStalenessPeriodUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetOwnerUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"owner\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TableUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"operatorSetInfo\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorSetInfo\",\"components\":[{\"name\":\"operatorInfoTreeRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"numOperators\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"aggregatePubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"totalWeights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CertificateStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ECAddFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ECMulFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ECPairingFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ExpModFailed\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorIndex\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidProofLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyTableUpdater\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ReferenceTimestampDoesNotExist\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TableUpdateStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"VerificationFailed\",\"inputs\":[]}]", - Bin: "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", + Bin: "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", } // BN254CertificateVerifierABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/ECDSACertificateVerifier/binding.go b/pkg/bindings/ECDSACertificateVerifier/binding.go new file mode 100644 index 0000000000..5da2b21c0c --- /dev/null +++ b/pkg/bindings/ECDSACertificateVerifier/binding.go @@ -0,0 +1,1130 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ECDSACertificateVerifier + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ICrossChainRegistryTypesOperatorSetConfig is an auto generated low-level Go binding around an user-defined struct. +type ICrossChainRegistryTypesOperatorSetConfig struct { + Owner common.Address + MaxStalenessPeriod uint32 +} + +// IECDSACertificateVerifierTypesECDSACertificate is an auto generated low-level Go binding around an user-defined struct. +type IECDSACertificateVerifierTypesECDSACertificate struct { + ReferenceTimestamp uint32 + MessageHash [32]byte + Sig []byte +} + +// IECDSATableCalculatorTypesECDSAOperatorInfo is an auto generated low-level Go binding around an user-defined struct. +type IECDSATableCalculatorTypesECDSAOperatorInfo struct { + Pubkey common.Address + Weights []*big.Int +} + +// OperatorSet is an auto generated low-level Go binding around an user-defined struct. +type OperatorSet struct { + Avs common.Address + Id uint32 +} + +// ECDSACertificateVerifierMetaData contains all meta data concerning the ECDSACertificateVerifier contract. +var ECDSACertificateVerifierMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_operatorTableUpdater\",\"type\":\"address\",\"internalType\":\"contractIOperatorTableUpdater\"},{\"name\":\"_version\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"calculateCertificateDigest\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"domainSeparator\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorInfos\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"tuple[]\",\"internalType\":\"structIECDSATableCalculatorTypes.ECDSAOperatorInfo[]\",\"components\":[{\"name\":\"pubkey\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getOperatorSetOwner\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"latestReferenceTimestamp\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maxOperatorTableStaleness\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorTableUpdater\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIOperatorTableUpdater\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfos\",\"type\":\"tuple[]\",\"internalType\":\"structIECDSATableCalculatorTypes.ECDSAOperatorInfo[]\",\"components\":[{\"name\":\"pubkey\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"operatorSetConfig\",\"type\":\"tuple\",\"internalType\":\"structICrossChainRegistryTypes.OperatorSetConfig\",\"components\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificate\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"verifyCertificateNominal\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"totalStakeNominalThresholds\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"verifyCertificateProportion\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"totalStakeProportionThresholds\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"MaxStalenessPeriodUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetOwnerUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"owner\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TableUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"operatorInfos\",\"type\":\"tuple[]\",\"indexed\":false,\"internalType\":\"structIECDSATableCalculatorTypes.ECDSAOperatorInfo[]\",\"components\":[{\"name\":\"pubkey\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CertificateStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidShortString\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignature\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignatureLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyTableUpdater\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ReferenceTimestampDoesNotExist\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"SignatureExpired\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StringTooLong\",\"inputs\":[{\"name\":\"str\",\"type\":\"string\",\"internalType\":\"string\"}]},{\"type\":\"error\",\"name\":\"TableUpdateStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"VerificationFailed\",\"inputs\":[]}]", + Bin: "0x60c060405234801561000f575f5ffd5b5060405161210238038061210283398101604081905261002e9161016d565b6001600160a01b03821660805280806100468161005b565b60a0525061005490506100a1565b5050610297565b5f5f829050601f8151111561008e578260405163305a27a960e01b8152600401610085919061023c565b60405180910390fd5b805161009982610271565b179392505050565b5f54610100900460ff16156101085760405162461bcd60e51b815260206004820152602760248201527f496e697469616c697a61626c653a20636f6e747261637420697320696e697469604482015266616c697a696e6760c81b6064820152608401610085565b5f5460ff90811614610157575f805460ff191660ff9081179091556040519081527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b565b634e487b7160e01b5f52604160045260245ffd5b5f5f6040838503121561017e575f5ffd5b82516001600160a01b0381168114610194575f5ffd5b60208401519092506001600160401b038111156101af575f5ffd5b8301601f810185136101bf575f5ffd5b80516001600160401b038111156101d8576101d8610159565b604051601f8201601f19908116603f011681016001600160401b038111828210171561020657610206610159565b60405281815282820160200187101561021d575f5ffd5b8160208401602083015e5f602083830101528093505050509250929050565b602081525f82518060208401528060208501604085015e5f604082850101526040601f19601f83011684010191505092915050565b80516020808301519190811015610291575f198160200360031b1b821691505b50919050565b60805160a051611e3c6102c65f395f81816102880152610f9f01525f818161014501526102bc0152611e3c5ff3fe608060405234801561000f575f5ffd5b50600436106100b1575f3560e01c80637c85ac4c1161006e5780637c85ac4c1461017f57806380c7d3f31461019f57806384818920146101bf578063be86e0b2146101d2578063c0da2420146101f5578063f698da2514610208575f5ffd5b806318467434146100b557806354fd4d50146100db57806356d482f5146100f05780635ddb9b5b146101055780636141879e1461012d57806368d6e08114610140575b5f5ffd5b6100c86100c33660046114f5565b610210565b6040519081526020015b60405180910390f35b6100e3610281565b6040516100d2919061154b565b6101036100fe3660046115b3565b6102b1565b005b6101186101133660046116dd565b6104b3565b60405163ffffffff90911681526020016100d2565b61011861013b3660046116dd565b6104d9565b6101677f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b0390911681526020016100d2565b61019261018d3660046116f7565b6104ff565b6040516100d29190611729565b6101b26101ad3660046117e7565b61066d565b6040516100d29190611832565b6101676101cd3660046116dd565b610680565b6101e56101e0366004611874565b6106a9565b60405190151581526020016100d2565b6101e5610203366004611956565b61073c565b6100c8610835565b604080517fda346acb3ce99e7c5132bf8cafb159ad8085970ebfdba78007ef0fe163063d14602082015263ffffffff841691810191909152606081018290525f908190608001604051602081830303815290604052805190602001209050610277816108f5565b9150505b92915050565b60606102ac7f000000000000000000000000000000000000000000000000000000000000000061093b565b905090565b336001600160a01b037f000000000000000000000000000000000000000000000000000000000000000016146102fa5760405163030c1b6b60e11b815260040160405180910390fd5b5f61031261030d368890038801886116dd565b610978565b5f8181526003602052604090205490915063ffffffff9081169086161161034c57604051632f20889f60e01b815260040160405180910390fd5b5f81815260046020908152604080832063ffffffff8916845290915281208490555b838110156103d857848482818110610388576103886119cc565b905060200281019061039a91906119e0565b5f83815260056020908152604080832063ffffffff808c168552908352818420908616845290915290206103ce8282611a29565b505060010161036e565b505f818152600360209081526040909120805463ffffffff191663ffffffff881617905561040890830183611b2c565b5f8281526001602090815260409182902080546001600160a01b0319166001600160a01b03949094169390931790925561044791908401908401611b47565b5f8281526002602052604090819020805463ffffffff191663ffffffff9390931692909217909155517f4f588da9ec57976194a79b5594f8f8782923d93013df2b9ed12fe125805011ef906104a3908890889088908890611b60565b60405180910390a1505050505050565b5f5f6104be83610978565b5f9081526003602052604090205463ffffffff169392505050565b5f5f6104e483610978565b5f9081526002602052604090205463ffffffff169392505050565b60605f61050b84610978565b5f81815260046020908152604080832063ffffffff8089168552925282205492935082166001600160401b0381111561054657610546611625565b60405190808252806020026020018201604052801561058b57816020015b604080518082019091525f8152606060208201528152602001906001900390816105645790505b5090505f5b8263ffffffff168163ffffffff161015610663575f84815260056020908152604080832063ffffffff808b16855290835281842090851684528252918290208251808401845281546001600160a01b031681526001820180548551818602810186019096528086529194929385810193929083018282801561062f57602002820191905f5260205f20905b81548152602001906001019080831161061b575b505050505081525050828263ffffffff1681518110610650576106506119cc565b6020908102919091010152600101610590565b5095945050505050565b606061067983836109db565b9392505050565b5f5f61068b83610978565b5f908152600160205260409020546001600160a01b03169392505050565b5f5f6106b585856109db565b905082518151146106d95760405163512509d360e11b815260040160405180910390fd5b5f5b8151811015610730578381815181106106f6576106f66119cc565b6020026020010151828281518110610710576107106119cc565b60200260200101511015610728575f92505050610679565b6001016106db565b50600195945050505050565b5f5f61074886866109db565b90505f6107618761075c6020890189611b47565b610d9c565b825190915084146107855760405163512509d360e11b815260040160405180910390fd5b5f5b8251811015610825575f6127108787848181106107a6576107a66119cc565b90506020020160208101906107bb9190611c93565b61ffff168484815181106107d1576107d16119cc565b60200260200101516107e39190611a12565b6107ed9190611cc8565b905080848381518110610802576108026119cc565b6020026020010151101561081c575f94505050505061082d565b50600101610787565b506001925050505b949350505050565b60408051808201909152600a81526922b4b3b2b72630bcb2b960b11b6020909101525f7f91ab3d17e3a50a9d89e63fd30b92be7f5336b03b287bb946787a83a9d62a27667f71b625cfad44bac63b13dba07f2e1d6084ee04b6f8752101ece6126d584ee6ea6108a2610f97565b80516020918201206040516108da949392309101938452602084019290925260408301526001600160a01b0316606082015260800190565b60405160208183030381529060405280519060200120905090565b5f6108fe610835565b60405161190160f01b6020820152602281019190915260428101839052606201604051602081830303815290604052805190602001209050919050565b60605f6109478361100c565b6040805160208082528183019092529192505f91906020820181803683375050509182525060208101929092525090565b5f815f0151826020015163ffffffff166040516020016109c392919060609290921b6bffffffffffffffffffffffff1916825260a01b6001600160a01b031916601482015260200190565b60405160208183030381529060405261027b90611cdb565b60605f6109f061030d368690038601866116dd565b5f8181526002602090815260409091205491925063ffffffff90911690610a1990850185611b47565b610a239190611cfe565b63ffffffff16421115610a495760405163640fcd6b60e11b815260040160405180910390fd5b610a566020840184611b47565b5f8281526003602052604090205463ffffffff908116911614610a8c57604051630cad17b760e31b815260040160405180910390fd5b5f610a9e8561075c6020870187611b47565b90505f81516001600160401b03811115610aba57610aba611625565b604051908082528060200260200182016040528015610ae3578160200160208202803683370190505b5090505f610b01610af76020880188611b47565b8760200135610210565b90505f80610b4f83610b1660408b018b611d1a565b8080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525061103392505050565b9150915080610b715760405163439cc0cd60e01b815260040160405180910390fd5b5f5b8251811015610d8e575f838281518110610b8f57610b8f6119cc565b602002602001015190505f5f9050610bc260405180604001604052805f6001600160a01b03168152602001606081525090565b5f5b60045f8c81526020019081526020015f205f8e5f016020810190610be89190611b47565b63ffffffff1663ffffffff1681526020019081526020015f2054811015610ced5760055f8c81526020019081526020015f205f8e5f016020810190610c2d9190611b47565b63ffffffff908116825260208083019390935260409182015f90812091851681529083528190208151808301835281546001600160a01b031681526001820180548451818702810187019095528085529194929385840193909290830182828015610cb557602002820191905f5260205f20905b815481526020019060010190808311610ca1575b5050505050815250509150836001600160a01b0316825f01516001600160a01b031603610ce55760019250610ced565b600101610bc4565b5081610d0c5760405163439cc0cd60e01b815260040160405180910390fd5b60208101515f5b815181108015610d235750895181105b15610d7d57818181518110610d3a57610d3a6119cc565b60200260200101518a8281518110610d5457610d546119cc565b60200260200101818151610d689190611d5c565b90525080610d7581611d6f565b915050610d13565b505060019093019250610b73915050565b509298975050505050505050565b60605f610db161030d368690038601866116dd565b5f8181526003602052604090205490915063ffffffff848116911614610dea57604051630cad17b760e31b815260040160405180910390fd5b5f81815260046020908152604080832063ffffffff8716845290915290205480610e2757604051630cad17b760e31b815260040160405180910390fd5b5f82815260056020908152604080832063ffffffff881684528252808320838052909152902060010154806001600160401b03811115610e6957610e69611625565b604051908082528060200260200182016040528015610e92578160200160208202803683370190505b5093505f5b82811015610f8d575f84815260056020908152604080832063ffffffff808b1685529083528184209085168452825280832060010180548251818502810185019093528083529192909190830182828015610f0f57602002820191905f5260205f20905b815481526020019060010190808311610efb575b509394505f93505050505b815181108015610f2957508381105b15610f8357818181518110610f4057610f406119cc565b6020026020010151878281518110610f5a57610f5a6119cc565b60200260200101818151610f6e9190611d5c565b90525080610f7b81611d6f565b915050610f1a565b5050600101610e97565b5050505092915050565b60605f610fc37f000000000000000000000000000000000000000000000000000000000000000061093b565b9050805f81518110610fd757610fd76119cc565b016020908101516040516001600160f81b03199091169181019190915260210160405160208183030381529060405291505090565b5f60ff8216601f81111561027b57604051632cd44ac360e21b815260040160405180910390fd5b60605f604183516110449190611d87565b1561106257604051634be6321b60e01b815260040160405180910390fd5b5f604184516110719190611cc8565b9050806001600160401b0381111561108b5761108b611625565b6040519080825280602002602001820160405280156110b4578160200160208202803683370190505b5092505f5b8181101561123657604080516041808252608082019092525f916020820181803683370190505090505f5b604181101561114f5786816110fa856041611a12565b6111049190611d5c565b81518110611114576111146119cc565b602001015160f81c60f81b828281518110611131576111316119cc565b60200101906001600160f81b03191690815f1a9053506001016110e4565b505f5f61115c8984611244565b90925090505f81600481111561117457611174611d9a565b14158061118857506001600160a01b038216155b1561119b57505f945061123d9350505050565b5f841180156111df5750866111b1600186611dae565b815181106111c1576111c16119cc565b60200260200101516001600160a01b0316826001600160a01b031611155b156111f257505f945061123d9350505050565b6111ff828a855f19611283565b81878581518110611212576112126119cc565b6001600160a01b0392909216602092830291909101909101525050506001016110b9565b5060019150505b9250929050565b5f5f8251604103611278576020830151604084015160608501515f1a61126c878285856112db565b9450945050505061123d565b505f9050600261123d565b428110156112a457604051630819bdcd60e01b815260040160405180910390fd5b6112b86001600160a01b0385168484611398565b6112d557604051638baa579f60e01b815260040160405180910390fd5b50505050565b5f807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a083111561131057505f9050600361138f565b604080515f8082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015611361573d5f5f3e3d5ffd5b5050604051601f1901519150506001600160a01b038116611389575f6001925092505061138f565b91505f90505b94509492505050565b5f5f5f6113a58585611244565b90925090505f8160048111156113bd576113bd611d9a565b1480156113db5750856001600160a01b0316826001600160a01b0316145b806113ec57506113ec8686866113f6565b9695505050505050565b5f5f5f856001600160a01b0316631626ba7e60e01b868660405160240161141e929190611dc1565b60408051601f198184030181529181526020820180516001600160e01b03166001600160e01b031990941693909317909252905161145c9190611dd9565b5f60405180830381855afa9150503d805f8114611494576040519150601f19603f3d011682016040523d82523d5f602084013e611499565b606091505b50915091508180156114ad57506020815110155b80156113ec57508051630b135d3f60e11b906114d29083016020908101908401611def565b149695505050505050565b803563ffffffff811681146114f0575f5ffd5b919050565b5f5f60408385031215611506575f5ffd5b61150f836114dd565b946020939093013593505050565b5f81518084528060208401602086015e5f602082860101526020601f19601f83011685010191505092915050565b602081525f610679602083018461151d565b5f6040828403121561156d575f5ffd5b50919050565b5f5f83601f840112611583575f5ffd5b5081356001600160401b03811115611599575f5ffd5b6020830191508360208260051b850101111561123d575f5ffd5b5f5f5f5f5f60c086880312156115c7575f5ffd5b6115d1878761155d565b94506115df604087016114dd565b935060608601356001600160401b038111156115f9575f5ffd5b61160588828901611573565b90945092506116199050876080880161155d565b90509295509295909350565b634e487b7160e01b5f52604160045260245ffd5b604051601f8201601f191681016001600160401b038111828210171561166157611661611625565b604052919050565b6001600160a01b038116811461167d575f5ffd5b50565b5f60408284031215611690575f5ffd5b604080519081016001600160401b03811182821017156116b2576116b2611625565b60405290508082356116c381611669565b81526116d1602084016114dd565b60208201525092915050565b5f604082840312156116ed575f5ffd5b6106798383611680565b5f5f60608385031215611708575f5ffd5b6117128484611680565b9150611720604084016114dd565b90509250929050565b5f602082016020835280845180835260408501915060408160051b8601019250602086015f5b828110156117cb57868503603f19018452815180516001600160a01b03168652602090810151604082880181905281519088018190529101905f9060608801905b808310156117b35783518252602082019150602084019350600183019250611790565b5096505050602093840193919091019060010161174f565b50929695505050505050565b5f6060828403121561156d575f5ffd5b5f5f606083850312156117f8575f5ffd5b611802848461155d565b915060408301356001600160401b0381111561181c575f5ffd5b611828858286016117d7565b9150509250929050565b602080825282518282018190525f918401906040840190835b8181101561186957835183526020938401939092019160010161184b565b509095945050505050565b5f5f5f60808486031215611886575f5ffd5b611890858561155d565b925060408401356001600160401b038111156118aa575f5ffd5b6118b6868287016117d7565b92505060608401356001600160401b038111156118d1575f5ffd5b8401601f810186136118e1575f5ffd5b80356001600160401b038111156118fa576118fa611625565b8060051b61190a60208201611639565b91825260208184018101929081019089841115611925575f5ffd5b6020850194505b8385101561194757843582526020948501949091019061192c565b80955050505050509250925092565b5f5f5f5f60808587031215611969575f5ffd5b611973868661155d565b935060408501356001600160401b0381111561198d575f5ffd5b611999878288016117d7565b93505060608501356001600160401b038111156119b4575f5ffd5b6119c087828801611573565b95989497509550505050565b634e487b7160e01b5f52603260045260245ffd5b5f8235603e198336030181126119f4575f5ffd5b9190910192915050565b634e487b7160e01b5f52601160045260245ffd5b808202811582820484141761027b5761027b6119fe565b8135611a3481611669565b81546001600160a01b0319166001600160a01b0391909116178155602082013536839003601e19018112611a66575f5ffd5b820180356001600160401b03811115611a7d575f5ffd5b6020820191508060051b3603821315611a94575f5ffd5b600183016001600160401b03821115611aaf57611aaf611625565b68010000000000000000821115611ac857611ac8611625565b805482825580831015611afd575f828152602090208381019082015b80821015611afa575f8255600182019150611ae4565b50505b505f90815260208120905b82811015611b2457833582820155602090930192600101611b08565b505050505050565b5f60208284031215611b3c575f5ffd5b813561067981611669565b5f60208284031215611b57575f5ffd5b610679826114dd565b5f608082018635611b7081611669565b6001600160a01b0316835263ffffffff611b8c602089016114dd565b16602084015263ffffffff861660408401526080606084015283905260a0600584901b83018101908301855f603e1936839003015b87821015611c8457868503609f190184528235818112611bdf575f5ffd5b89018035611bec81611669565b6001600160a01b03168652602081013536829003601e19018112611c0e575f5ffd5b016020810190356001600160401b03811115611c28575f5ffd5b8060051b803603831315611c3a575f5ffd5b60406020890181905288018290526001600160fb1b03821115611c5b575f5ffd5b808360608a01376060818901019750505050602083019250602084019350600182019150611bc1565b50929998505050505050505050565b5f60208284031215611ca3575f5ffd5b813561ffff81168114610679575f5ffd5b634e487b7160e01b5f52601260045260245ffd5b5f82611cd657611cd6611cb4565b500490565b8051602080830151919081101561156d575f1960209190910360031b1b16919050565b63ffffffff818116838216019081111561027b5761027b6119fe565b5f5f8335601e19843603018112611d2f575f5ffd5b8301803591506001600160401b03821115611d48575f5ffd5b60200191503681900382131561123d575f5ffd5b8082018082111561027b5761027b6119fe565b5f60018201611d8057611d806119fe565b5060010190565b5f82611d9557611d95611cb4565b500690565b634e487b7160e01b5f52602160045260245ffd5b8181038181111561027b5761027b6119fe565b828152604060208201525f61082d604083018461151d565b5f82518060208501845e5f920191825250919050565b5f60208284031215611dff575f5ffd5b505191905056fea2646970667358221220cf3110fa768133096172cf340011c6d6e7eef37aa83faeb7c2e4111966e82fd164736f6c634300081b0033", +} + +// ECDSACertificateVerifierABI is the input ABI used to generate the binding from. +// Deprecated: Use ECDSACertificateVerifierMetaData.ABI instead. +var ECDSACertificateVerifierABI = ECDSACertificateVerifierMetaData.ABI + +// ECDSACertificateVerifierBin is the compiled bytecode used for deploying new contracts. +// Deprecated: Use ECDSACertificateVerifierMetaData.Bin instead. +var ECDSACertificateVerifierBin = ECDSACertificateVerifierMetaData.Bin + +// DeployECDSACertificateVerifier deploys a new Ethereum contract, binding an instance of ECDSACertificateVerifier to it. +func DeployECDSACertificateVerifier(auth *bind.TransactOpts, backend bind.ContractBackend, _operatorTableUpdater common.Address, _version string) (common.Address, *types.Transaction, *ECDSACertificateVerifier, error) { + parsed, err := ECDSACertificateVerifierMetaData.GetAbi() + if err != nil { + return common.Address{}, nil, nil, err + } + if parsed == nil { + return common.Address{}, nil, nil, errors.New("GetABI returned nil") + } + + address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(ECDSACertificateVerifierBin), backend, _operatorTableUpdater, _version) + if err != nil { + return common.Address{}, nil, nil, err + } + return address, tx, &ECDSACertificateVerifier{ECDSACertificateVerifierCaller: ECDSACertificateVerifierCaller{contract: contract}, ECDSACertificateVerifierTransactor: ECDSACertificateVerifierTransactor{contract: contract}, ECDSACertificateVerifierFilterer: ECDSACertificateVerifierFilterer{contract: contract}}, nil +} + +// ECDSACertificateVerifier is an auto generated Go binding around an Ethereum contract. +type ECDSACertificateVerifier struct { + ECDSACertificateVerifierCaller // Read-only binding to the contract + ECDSACertificateVerifierTransactor // Write-only binding to the contract + ECDSACertificateVerifierFilterer // Log filterer for contract events +} + +// ECDSACertificateVerifierCaller is an auto generated read-only Go binding around an Ethereum contract. +type ECDSACertificateVerifierCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ECDSACertificateVerifierTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ECDSACertificateVerifierTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ECDSACertificateVerifierFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ECDSACertificateVerifierFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ECDSACertificateVerifierSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ECDSACertificateVerifierSession struct { + Contract *ECDSACertificateVerifier // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ECDSACertificateVerifierCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ECDSACertificateVerifierCallerSession struct { + Contract *ECDSACertificateVerifierCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ECDSACertificateVerifierTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ECDSACertificateVerifierTransactorSession struct { + Contract *ECDSACertificateVerifierTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ECDSACertificateVerifierRaw is an auto generated low-level Go binding around an Ethereum contract. +type ECDSACertificateVerifierRaw struct { + Contract *ECDSACertificateVerifier // Generic contract binding to access the raw methods on +} + +// ECDSACertificateVerifierCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ECDSACertificateVerifierCallerRaw struct { + Contract *ECDSACertificateVerifierCaller // Generic read-only contract binding to access the raw methods on +} + +// ECDSACertificateVerifierTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ECDSACertificateVerifierTransactorRaw struct { + Contract *ECDSACertificateVerifierTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewECDSACertificateVerifier creates a new instance of ECDSACertificateVerifier, bound to a specific deployed contract. +func NewECDSACertificateVerifier(address common.Address, backend bind.ContractBackend) (*ECDSACertificateVerifier, error) { + contract, err := bindECDSACertificateVerifier(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ECDSACertificateVerifier{ECDSACertificateVerifierCaller: ECDSACertificateVerifierCaller{contract: contract}, ECDSACertificateVerifierTransactor: ECDSACertificateVerifierTransactor{contract: contract}, ECDSACertificateVerifierFilterer: ECDSACertificateVerifierFilterer{contract: contract}}, nil +} + +// NewECDSACertificateVerifierCaller creates a new read-only instance of ECDSACertificateVerifier, bound to a specific deployed contract. +func NewECDSACertificateVerifierCaller(address common.Address, caller bind.ContractCaller) (*ECDSACertificateVerifierCaller, error) { + contract, err := bindECDSACertificateVerifier(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierCaller{contract: contract}, nil +} + +// NewECDSACertificateVerifierTransactor creates a new write-only instance of ECDSACertificateVerifier, bound to a specific deployed contract. +func NewECDSACertificateVerifierTransactor(address common.Address, transactor bind.ContractTransactor) (*ECDSACertificateVerifierTransactor, error) { + contract, err := bindECDSACertificateVerifier(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierTransactor{contract: contract}, nil +} + +// NewECDSACertificateVerifierFilterer creates a new log filterer instance of ECDSACertificateVerifier, bound to a specific deployed contract. +func NewECDSACertificateVerifierFilterer(address common.Address, filterer bind.ContractFilterer) (*ECDSACertificateVerifierFilterer, error) { + contract, err := bindECDSACertificateVerifier(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierFilterer{contract: contract}, nil +} + +// bindECDSACertificateVerifier binds a generic wrapper to an already deployed contract. +func bindECDSACertificateVerifier(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ECDSACertificateVerifierMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ECDSACertificateVerifier *ECDSACertificateVerifierRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ECDSACertificateVerifier.Contract.ECDSACertificateVerifierCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ECDSACertificateVerifier *ECDSACertificateVerifierRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ECDSACertificateVerifier.Contract.ECDSACertificateVerifierTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ECDSACertificateVerifier *ECDSACertificateVerifierRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ECDSACertificateVerifier.Contract.ECDSACertificateVerifierTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ECDSACertificateVerifier.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ECDSACertificateVerifier *ECDSACertificateVerifierTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ECDSACertificateVerifier.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ECDSACertificateVerifier *ECDSACertificateVerifierTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ECDSACertificateVerifier.Contract.contract.Transact(opts, method, params...) +} + +// CalculateCertificateDigest is a free data retrieval call binding the contract method 0x18467434. +// +// Solidity: function calculateCertificateDigest(uint32 referenceTimestamp, bytes32 messageHash) view returns(bytes32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) CalculateCertificateDigest(opts *bind.CallOpts, referenceTimestamp uint32, messageHash [32]byte) ([32]byte, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "calculateCertificateDigest", referenceTimestamp, messageHash) + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// CalculateCertificateDigest is a free data retrieval call binding the contract method 0x18467434. +// +// Solidity: function calculateCertificateDigest(uint32 referenceTimestamp, bytes32 messageHash) view returns(bytes32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) CalculateCertificateDigest(referenceTimestamp uint32, messageHash [32]byte) ([32]byte, error) { + return _ECDSACertificateVerifier.Contract.CalculateCertificateDigest(&_ECDSACertificateVerifier.CallOpts, referenceTimestamp, messageHash) +} + +// CalculateCertificateDigest is a free data retrieval call binding the contract method 0x18467434. +// +// Solidity: function calculateCertificateDigest(uint32 referenceTimestamp, bytes32 messageHash) view returns(bytes32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) CalculateCertificateDigest(referenceTimestamp uint32, messageHash [32]byte) ([32]byte, error) { + return _ECDSACertificateVerifier.Contract.CalculateCertificateDigest(&_ECDSACertificateVerifier.CallOpts, referenceTimestamp, messageHash) +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) DomainSeparator(opts *bind.CallOpts) ([32]byte, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "domainSeparator") + + if err != nil { + return *new([32]byte), err + } + + out0 := *abi.ConvertType(out[0], new([32]byte)).(*[32]byte) + + return out0, err + +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) DomainSeparator() ([32]byte, error) { + return _ECDSACertificateVerifier.Contract.DomainSeparator(&_ECDSACertificateVerifier.CallOpts) +} + +// DomainSeparator is a free data retrieval call binding the contract method 0xf698da25. +// +// Solidity: function domainSeparator() view returns(bytes32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) DomainSeparator() ([32]byte, error) { + return _ECDSACertificateVerifier.Contract.DomainSeparator(&_ECDSACertificateVerifier.CallOpts) +} + +// GetOperatorInfos is a free data retrieval call binding the contract method 0x7c85ac4c. +// +// Solidity: function getOperatorInfos((address,uint32) operatorSet, uint32 referenceTimestamp) view returns((address,uint256[])[]) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) GetOperatorInfos(opts *bind.CallOpts, operatorSet OperatorSet, referenceTimestamp uint32) ([]IECDSATableCalculatorTypesECDSAOperatorInfo, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "getOperatorInfos", operatorSet, referenceTimestamp) + + if err != nil { + return *new([]IECDSATableCalculatorTypesECDSAOperatorInfo), err + } + + out0 := *abi.ConvertType(out[0], new([]IECDSATableCalculatorTypesECDSAOperatorInfo)).(*[]IECDSATableCalculatorTypesECDSAOperatorInfo) + + return out0, err + +} + +// GetOperatorInfos is a free data retrieval call binding the contract method 0x7c85ac4c. +// +// Solidity: function getOperatorInfos((address,uint32) operatorSet, uint32 referenceTimestamp) view returns((address,uint256[])[]) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) GetOperatorInfos(operatorSet OperatorSet, referenceTimestamp uint32) ([]IECDSATableCalculatorTypesECDSAOperatorInfo, error) { + return _ECDSACertificateVerifier.Contract.GetOperatorInfos(&_ECDSACertificateVerifier.CallOpts, operatorSet, referenceTimestamp) +} + +// GetOperatorInfos is a free data retrieval call binding the contract method 0x7c85ac4c. +// +// Solidity: function getOperatorInfos((address,uint32) operatorSet, uint32 referenceTimestamp) view returns((address,uint256[])[]) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) GetOperatorInfos(operatorSet OperatorSet, referenceTimestamp uint32) ([]IECDSATableCalculatorTypesECDSAOperatorInfo, error) { + return _ECDSACertificateVerifier.Contract.GetOperatorInfos(&_ECDSACertificateVerifier.CallOpts, operatorSet, referenceTimestamp) +} + +// GetOperatorSetOwner is a free data retrieval call binding the contract method 0x84818920. +// +// Solidity: function getOperatorSetOwner((address,uint32) operatorSet) view returns(address) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) GetOperatorSetOwner(opts *bind.CallOpts, operatorSet OperatorSet) (common.Address, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "getOperatorSetOwner", operatorSet) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetOperatorSetOwner is a free data retrieval call binding the contract method 0x84818920. +// +// Solidity: function getOperatorSetOwner((address,uint32) operatorSet) view returns(address) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) GetOperatorSetOwner(operatorSet OperatorSet) (common.Address, error) { + return _ECDSACertificateVerifier.Contract.GetOperatorSetOwner(&_ECDSACertificateVerifier.CallOpts, operatorSet) +} + +// GetOperatorSetOwner is a free data retrieval call binding the contract method 0x84818920. +// +// Solidity: function getOperatorSetOwner((address,uint32) operatorSet) view returns(address) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) GetOperatorSetOwner(operatorSet OperatorSet) (common.Address, error) { + return _ECDSACertificateVerifier.Contract.GetOperatorSetOwner(&_ECDSACertificateVerifier.CallOpts, operatorSet) +} + +// LatestReferenceTimestamp is a free data retrieval call binding the contract method 0x5ddb9b5b. +// +// Solidity: function latestReferenceTimestamp((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) LatestReferenceTimestamp(opts *bind.CallOpts, operatorSet OperatorSet) (uint32, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "latestReferenceTimestamp", operatorSet) + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// LatestReferenceTimestamp is a free data retrieval call binding the contract method 0x5ddb9b5b. +// +// Solidity: function latestReferenceTimestamp((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) LatestReferenceTimestamp(operatorSet OperatorSet) (uint32, error) { + return _ECDSACertificateVerifier.Contract.LatestReferenceTimestamp(&_ECDSACertificateVerifier.CallOpts, operatorSet) +} + +// LatestReferenceTimestamp is a free data retrieval call binding the contract method 0x5ddb9b5b. +// +// Solidity: function latestReferenceTimestamp((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) LatestReferenceTimestamp(operatorSet OperatorSet) (uint32, error) { + return _ECDSACertificateVerifier.Contract.LatestReferenceTimestamp(&_ECDSACertificateVerifier.CallOpts, operatorSet) +} + +// MaxOperatorTableStaleness is a free data retrieval call binding the contract method 0x6141879e. +// +// Solidity: function maxOperatorTableStaleness((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) MaxOperatorTableStaleness(opts *bind.CallOpts, operatorSet OperatorSet) (uint32, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "maxOperatorTableStaleness", operatorSet) + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// MaxOperatorTableStaleness is a free data retrieval call binding the contract method 0x6141879e. +// +// Solidity: function maxOperatorTableStaleness((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) MaxOperatorTableStaleness(operatorSet OperatorSet) (uint32, error) { + return _ECDSACertificateVerifier.Contract.MaxOperatorTableStaleness(&_ECDSACertificateVerifier.CallOpts, operatorSet) +} + +// MaxOperatorTableStaleness is a free data retrieval call binding the contract method 0x6141879e. +// +// Solidity: function maxOperatorTableStaleness((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) MaxOperatorTableStaleness(operatorSet OperatorSet) (uint32, error) { + return _ECDSACertificateVerifier.Contract.MaxOperatorTableStaleness(&_ECDSACertificateVerifier.CallOpts, operatorSet) +} + +// OperatorTableUpdater is a free data retrieval call binding the contract method 0x68d6e081. +// +// Solidity: function operatorTableUpdater() view returns(address) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) OperatorTableUpdater(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "operatorTableUpdater") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// OperatorTableUpdater is a free data retrieval call binding the contract method 0x68d6e081. +// +// Solidity: function operatorTableUpdater() view returns(address) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) OperatorTableUpdater() (common.Address, error) { + return _ECDSACertificateVerifier.Contract.OperatorTableUpdater(&_ECDSACertificateVerifier.CallOpts) +} + +// OperatorTableUpdater is a free data retrieval call binding the contract method 0x68d6e081. +// +// Solidity: function operatorTableUpdater() view returns(address) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) OperatorTableUpdater() (common.Address, error) { + return _ECDSACertificateVerifier.Contract.OperatorTableUpdater(&_ECDSACertificateVerifier.CallOpts) +} + +// VerifyCertificate is a free data retrieval call binding the contract method 0x80c7d3f3. +// +// Solidity: function verifyCertificate((address,uint32) operatorSet, (uint32,bytes32,bytes) cert) view returns(uint256[]) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) VerifyCertificate(opts *bind.CallOpts, operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate) ([]*big.Int, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "verifyCertificate", operatorSet, cert) + + if err != nil { + return *new([]*big.Int), err + } + + out0 := *abi.ConvertType(out[0], new([]*big.Int)).(*[]*big.Int) + + return out0, err + +} + +// VerifyCertificate is a free data retrieval call binding the contract method 0x80c7d3f3. +// +// Solidity: function verifyCertificate((address,uint32) operatorSet, (uint32,bytes32,bytes) cert) view returns(uint256[]) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) VerifyCertificate(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate) ([]*big.Int, error) { + return _ECDSACertificateVerifier.Contract.VerifyCertificate(&_ECDSACertificateVerifier.CallOpts, operatorSet, cert) +} + +// VerifyCertificate is a free data retrieval call binding the contract method 0x80c7d3f3. +// +// Solidity: function verifyCertificate((address,uint32) operatorSet, (uint32,bytes32,bytes) cert) view returns(uint256[]) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) VerifyCertificate(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate) ([]*big.Int, error) { + return _ECDSACertificateVerifier.Contract.VerifyCertificate(&_ECDSACertificateVerifier.CallOpts, operatorSet, cert) +} + +// VerifyCertificateNominal is a free data retrieval call binding the contract method 0xbe86e0b2. +// +// Solidity: function verifyCertificateNominal((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint256[] totalStakeNominalThresholds) view returns(bool) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) VerifyCertificateNominal(opts *bind.CallOpts, operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeNominalThresholds []*big.Int) (bool, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "verifyCertificateNominal", operatorSet, cert, totalStakeNominalThresholds) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// VerifyCertificateNominal is a free data retrieval call binding the contract method 0xbe86e0b2. +// +// Solidity: function verifyCertificateNominal((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint256[] totalStakeNominalThresholds) view returns(bool) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) VerifyCertificateNominal(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeNominalThresholds []*big.Int) (bool, error) { + return _ECDSACertificateVerifier.Contract.VerifyCertificateNominal(&_ECDSACertificateVerifier.CallOpts, operatorSet, cert, totalStakeNominalThresholds) +} + +// VerifyCertificateNominal is a free data retrieval call binding the contract method 0xbe86e0b2. +// +// Solidity: function verifyCertificateNominal((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint256[] totalStakeNominalThresholds) view returns(bool) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) VerifyCertificateNominal(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeNominalThresholds []*big.Int) (bool, error) { + return _ECDSACertificateVerifier.Contract.VerifyCertificateNominal(&_ECDSACertificateVerifier.CallOpts, operatorSet, cert, totalStakeNominalThresholds) +} + +// VerifyCertificateProportion is a free data retrieval call binding the contract method 0xc0da2420. +// +// Solidity: function verifyCertificateProportion((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint16[] totalStakeProportionThresholds) view returns(bool) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) VerifyCertificateProportion(opts *bind.CallOpts, operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeProportionThresholds []uint16) (bool, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "verifyCertificateProportion", operatorSet, cert, totalStakeProportionThresholds) + + if err != nil { + return *new(bool), err + } + + out0 := *abi.ConvertType(out[0], new(bool)).(*bool) + + return out0, err + +} + +// VerifyCertificateProportion is a free data retrieval call binding the contract method 0xc0da2420. +// +// Solidity: function verifyCertificateProportion((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint16[] totalStakeProportionThresholds) view returns(bool) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) VerifyCertificateProportion(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeProportionThresholds []uint16) (bool, error) { + return _ECDSACertificateVerifier.Contract.VerifyCertificateProportion(&_ECDSACertificateVerifier.CallOpts, operatorSet, cert, totalStakeProportionThresholds) +} + +// VerifyCertificateProportion is a free data retrieval call binding the contract method 0xc0da2420. +// +// Solidity: function verifyCertificateProportion((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint16[] totalStakeProportionThresholds) view returns(bool) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) VerifyCertificateProportion(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeProportionThresholds []uint16) (bool, error) { + return _ECDSACertificateVerifier.Contract.VerifyCertificateProportion(&_ECDSACertificateVerifier.CallOpts, operatorSet, cert, totalStakeProportionThresholds) +} + +// Version is a free data retrieval call binding the contract method 0x54fd4d50. +// +// Solidity: function version() view returns(string) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCaller) Version(opts *bind.CallOpts) (string, error) { + var out []interface{} + err := _ECDSACertificateVerifier.contract.Call(opts, &out, "version") + + if err != nil { + return *new(string), err + } + + out0 := *abi.ConvertType(out[0], new(string)).(*string) + + return out0, err + +} + +// Version is a free data retrieval call binding the contract method 0x54fd4d50. +// +// Solidity: function version() view returns(string) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) Version() (string, error) { + return _ECDSACertificateVerifier.Contract.Version(&_ECDSACertificateVerifier.CallOpts) +} + +// Version is a free data retrieval call binding the contract method 0x54fd4d50. +// +// Solidity: function version() view returns(string) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierCallerSession) Version() (string, error) { + return _ECDSACertificateVerifier.Contract.Version(&_ECDSACertificateVerifier.CallOpts) +} + +// UpdateOperatorTable is a paid mutator transaction binding the contract method 0x56d482f5. +// +// Solidity: function updateOperatorTable((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos, (address,uint32) operatorSetConfig) returns() +func (_ECDSACertificateVerifier *ECDSACertificateVerifierTransactor) UpdateOperatorTable(opts *bind.TransactOpts, operatorSet OperatorSet, referenceTimestamp uint32, operatorInfos []IECDSATableCalculatorTypesECDSAOperatorInfo, operatorSetConfig ICrossChainRegistryTypesOperatorSetConfig) (*types.Transaction, error) { + return _ECDSACertificateVerifier.contract.Transact(opts, "updateOperatorTable", operatorSet, referenceTimestamp, operatorInfos, operatorSetConfig) +} + +// UpdateOperatorTable is a paid mutator transaction binding the contract method 0x56d482f5. +// +// Solidity: function updateOperatorTable((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos, (address,uint32) operatorSetConfig) returns() +func (_ECDSACertificateVerifier *ECDSACertificateVerifierSession) UpdateOperatorTable(operatorSet OperatorSet, referenceTimestamp uint32, operatorInfos []IECDSATableCalculatorTypesECDSAOperatorInfo, operatorSetConfig ICrossChainRegistryTypesOperatorSetConfig) (*types.Transaction, error) { + return _ECDSACertificateVerifier.Contract.UpdateOperatorTable(&_ECDSACertificateVerifier.TransactOpts, operatorSet, referenceTimestamp, operatorInfos, operatorSetConfig) +} + +// UpdateOperatorTable is a paid mutator transaction binding the contract method 0x56d482f5. +// +// Solidity: function updateOperatorTable((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos, (address,uint32) operatorSetConfig) returns() +func (_ECDSACertificateVerifier *ECDSACertificateVerifierTransactorSession) UpdateOperatorTable(operatorSet OperatorSet, referenceTimestamp uint32, operatorInfos []IECDSATableCalculatorTypesECDSAOperatorInfo, operatorSetConfig ICrossChainRegistryTypesOperatorSetConfig) (*types.Transaction, error) { + return _ECDSACertificateVerifier.Contract.UpdateOperatorTable(&_ECDSACertificateVerifier.TransactOpts, operatorSet, referenceTimestamp, operatorInfos, operatorSetConfig) +} + +// ECDSACertificateVerifierInitializedIterator is returned from FilterInitialized and is used to iterate over the raw logs and unpacked data for Initialized events raised by the ECDSACertificateVerifier contract. +type ECDSACertificateVerifierInitializedIterator struct { + Event *ECDSACertificateVerifierInitialized // 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 *ECDSACertificateVerifierInitializedIterator) 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(ECDSACertificateVerifierInitialized) + 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(ECDSACertificateVerifierInitialized) + 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 *ECDSACertificateVerifierInitializedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ECDSACertificateVerifierInitializedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ECDSACertificateVerifierInitialized represents a Initialized event raised by the ECDSACertificateVerifier contract. +type ECDSACertificateVerifierInitialized struct { + Version uint8 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterInitialized is a free log retrieval operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) FilterInitialized(opts *bind.FilterOpts) (*ECDSACertificateVerifierInitializedIterator, error) { + + logs, sub, err := _ECDSACertificateVerifier.contract.FilterLogs(opts, "Initialized") + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierInitializedIterator{contract: _ECDSACertificateVerifier.contract, event: "Initialized", logs: logs, sub: sub}, nil +} + +// WatchInitialized is a free log subscription operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) WatchInitialized(opts *bind.WatchOpts, sink chan<- *ECDSACertificateVerifierInitialized) (event.Subscription, error) { + + logs, sub, err := _ECDSACertificateVerifier.contract.WatchLogs(opts, "Initialized") + 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(ECDSACertificateVerifierInitialized) + if err := _ECDSACertificateVerifier.contract.UnpackLog(event, "Initialized", 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 +} + +// ParseInitialized is a log parse operation binding the contract event 0x7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498. +// +// Solidity: event Initialized(uint8 version) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) ParseInitialized(log types.Log) (*ECDSACertificateVerifierInitialized, error) { + event := new(ECDSACertificateVerifierInitialized) + if err := _ECDSACertificateVerifier.contract.UnpackLog(event, "Initialized", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ECDSACertificateVerifierMaxStalenessPeriodUpdatedIterator is returned from FilterMaxStalenessPeriodUpdated and is used to iterate over the raw logs and unpacked data for MaxStalenessPeriodUpdated events raised by the ECDSACertificateVerifier contract. +type ECDSACertificateVerifierMaxStalenessPeriodUpdatedIterator struct { + Event *ECDSACertificateVerifierMaxStalenessPeriodUpdated // 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 *ECDSACertificateVerifierMaxStalenessPeriodUpdatedIterator) 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(ECDSACertificateVerifierMaxStalenessPeriodUpdated) + 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(ECDSACertificateVerifierMaxStalenessPeriodUpdated) + 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 *ECDSACertificateVerifierMaxStalenessPeriodUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ECDSACertificateVerifierMaxStalenessPeriodUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ECDSACertificateVerifierMaxStalenessPeriodUpdated represents a MaxStalenessPeriodUpdated event raised by the ECDSACertificateVerifier contract. +type ECDSACertificateVerifierMaxStalenessPeriodUpdated struct { + OperatorSet OperatorSet + MaxStalenessPeriod uint32 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterMaxStalenessPeriodUpdated is a free log retrieval operation binding the contract event 0x28539469fbbc8a5482e60966bf9376f7b9d25b2f0a65a9976f6baa3f0e3788da. +// +// Solidity: event MaxStalenessPeriodUpdated((address,uint32) operatorSet, uint32 maxStalenessPeriod) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) FilterMaxStalenessPeriodUpdated(opts *bind.FilterOpts) (*ECDSACertificateVerifierMaxStalenessPeriodUpdatedIterator, error) { + + logs, sub, err := _ECDSACertificateVerifier.contract.FilterLogs(opts, "MaxStalenessPeriodUpdated") + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierMaxStalenessPeriodUpdatedIterator{contract: _ECDSACertificateVerifier.contract, event: "MaxStalenessPeriodUpdated", logs: logs, sub: sub}, nil +} + +// WatchMaxStalenessPeriodUpdated is a free log subscription operation binding the contract event 0x28539469fbbc8a5482e60966bf9376f7b9d25b2f0a65a9976f6baa3f0e3788da. +// +// Solidity: event MaxStalenessPeriodUpdated((address,uint32) operatorSet, uint32 maxStalenessPeriod) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) WatchMaxStalenessPeriodUpdated(opts *bind.WatchOpts, sink chan<- *ECDSACertificateVerifierMaxStalenessPeriodUpdated) (event.Subscription, error) { + + logs, sub, err := _ECDSACertificateVerifier.contract.WatchLogs(opts, "MaxStalenessPeriodUpdated") + 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(ECDSACertificateVerifierMaxStalenessPeriodUpdated) + if err := _ECDSACertificateVerifier.contract.UnpackLog(event, "MaxStalenessPeriodUpdated", 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 +} + +// ParseMaxStalenessPeriodUpdated is a log parse operation binding the contract event 0x28539469fbbc8a5482e60966bf9376f7b9d25b2f0a65a9976f6baa3f0e3788da. +// +// Solidity: event MaxStalenessPeriodUpdated((address,uint32) operatorSet, uint32 maxStalenessPeriod) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) ParseMaxStalenessPeriodUpdated(log types.Log) (*ECDSACertificateVerifierMaxStalenessPeriodUpdated, error) { + event := new(ECDSACertificateVerifierMaxStalenessPeriodUpdated) + if err := _ECDSACertificateVerifier.contract.UnpackLog(event, "MaxStalenessPeriodUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ECDSACertificateVerifierOperatorSetOwnerUpdatedIterator is returned from FilterOperatorSetOwnerUpdated and is used to iterate over the raw logs and unpacked data for OperatorSetOwnerUpdated events raised by the ECDSACertificateVerifier contract. +type ECDSACertificateVerifierOperatorSetOwnerUpdatedIterator struct { + Event *ECDSACertificateVerifierOperatorSetOwnerUpdated // 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 *ECDSACertificateVerifierOperatorSetOwnerUpdatedIterator) 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(ECDSACertificateVerifierOperatorSetOwnerUpdated) + 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(ECDSACertificateVerifierOperatorSetOwnerUpdated) + 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 *ECDSACertificateVerifierOperatorSetOwnerUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ECDSACertificateVerifierOperatorSetOwnerUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ECDSACertificateVerifierOperatorSetOwnerUpdated represents a OperatorSetOwnerUpdated event raised by the ECDSACertificateVerifier contract. +type ECDSACertificateVerifierOperatorSetOwnerUpdated struct { + OperatorSet OperatorSet + Owner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOperatorSetOwnerUpdated is a free log retrieval operation binding the contract event 0x806dc367095c0baf953d7144b7c4376261675ee0b4e0da2761e43673051c7375. +// +// Solidity: event OperatorSetOwnerUpdated((address,uint32) operatorSet, address owner) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) FilterOperatorSetOwnerUpdated(opts *bind.FilterOpts) (*ECDSACertificateVerifierOperatorSetOwnerUpdatedIterator, error) { + + logs, sub, err := _ECDSACertificateVerifier.contract.FilterLogs(opts, "OperatorSetOwnerUpdated") + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierOperatorSetOwnerUpdatedIterator{contract: _ECDSACertificateVerifier.contract, event: "OperatorSetOwnerUpdated", logs: logs, sub: sub}, nil +} + +// WatchOperatorSetOwnerUpdated is a free log subscription operation binding the contract event 0x806dc367095c0baf953d7144b7c4376261675ee0b4e0da2761e43673051c7375. +// +// Solidity: event OperatorSetOwnerUpdated((address,uint32) operatorSet, address owner) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) WatchOperatorSetOwnerUpdated(opts *bind.WatchOpts, sink chan<- *ECDSACertificateVerifierOperatorSetOwnerUpdated) (event.Subscription, error) { + + logs, sub, err := _ECDSACertificateVerifier.contract.WatchLogs(opts, "OperatorSetOwnerUpdated") + 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(ECDSACertificateVerifierOperatorSetOwnerUpdated) + if err := _ECDSACertificateVerifier.contract.UnpackLog(event, "OperatorSetOwnerUpdated", 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 +} + +// ParseOperatorSetOwnerUpdated is a log parse operation binding the contract event 0x806dc367095c0baf953d7144b7c4376261675ee0b4e0da2761e43673051c7375. +// +// Solidity: event OperatorSetOwnerUpdated((address,uint32) operatorSet, address owner) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) ParseOperatorSetOwnerUpdated(log types.Log) (*ECDSACertificateVerifierOperatorSetOwnerUpdated, error) { + event := new(ECDSACertificateVerifierOperatorSetOwnerUpdated) + if err := _ECDSACertificateVerifier.contract.UnpackLog(event, "OperatorSetOwnerUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ECDSACertificateVerifierTableUpdatedIterator is returned from FilterTableUpdated and is used to iterate over the raw logs and unpacked data for TableUpdated events raised by the ECDSACertificateVerifier contract. +type ECDSACertificateVerifierTableUpdatedIterator struct { + Event *ECDSACertificateVerifierTableUpdated // 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 *ECDSACertificateVerifierTableUpdatedIterator) 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(ECDSACertificateVerifierTableUpdated) + 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(ECDSACertificateVerifierTableUpdated) + 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 *ECDSACertificateVerifierTableUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ECDSACertificateVerifierTableUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ECDSACertificateVerifierTableUpdated represents a TableUpdated event raised by the ECDSACertificateVerifier contract. +type ECDSACertificateVerifierTableUpdated struct { + OperatorSet OperatorSet + ReferenceTimestamp uint32 + OperatorInfos []IECDSATableCalculatorTypesECDSAOperatorInfo + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTableUpdated is a free log retrieval operation binding the contract event 0x4f588da9ec57976194a79b5594f8f8782923d93013df2b9ed12fe125805011ef. +// +// Solidity: event TableUpdated((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) FilterTableUpdated(opts *bind.FilterOpts) (*ECDSACertificateVerifierTableUpdatedIterator, error) { + + logs, sub, err := _ECDSACertificateVerifier.contract.FilterLogs(opts, "TableUpdated") + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierTableUpdatedIterator{contract: _ECDSACertificateVerifier.contract, event: "TableUpdated", logs: logs, sub: sub}, nil +} + +// WatchTableUpdated is a free log subscription operation binding the contract event 0x4f588da9ec57976194a79b5594f8f8782923d93013df2b9ed12fe125805011ef. +// +// Solidity: event TableUpdated((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) WatchTableUpdated(opts *bind.WatchOpts, sink chan<- *ECDSACertificateVerifierTableUpdated) (event.Subscription, error) { + + logs, sub, err := _ECDSACertificateVerifier.contract.WatchLogs(opts, "TableUpdated") + 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(ECDSACertificateVerifierTableUpdated) + if err := _ECDSACertificateVerifier.contract.UnpackLog(event, "TableUpdated", 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 +} + +// ParseTableUpdated is a log parse operation binding the contract event 0x4f588da9ec57976194a79b5594f8f8782923d93013df2b9ed12fe125805011ef. +// +// Solidity: event TableUpdated((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos) +func (_ECDSACertificateVerifier *ECDSACertificateVerifierFilterer) ParseTableUpdated(log types.Log) (*ECDSACertificateVerifierTableUpdated, error) { + event := new(ECDSACertificateVerifierTableUpdated) + if err := _ECDSACertificateVerifier.contract.UnpackLog(event, "TableUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/bindings/ECDSACertificateVerifierStorage/binding.go b/pkg/bindings/ECDSACertificateVerifierStorage/binding.go new file mode 100644 index 0000000000..decb703e87 --- /dev/null +++ b/pkg/bindings/ECDSACertificateVerifierStorage/binding.go @@ -0,0 +1,820 @@ +// Code generated - DO NOT EDIT. +// This file is a generated binding and any manual changes will be lost. + +package ECDSACertificateVerifierStorage + +import ( + "errors" + "math/big" + "strings" + + ethereum "github.com/ethereum/go-ethereum" + "github.com/ethereum/go-ethereum/accounts/abi" + "github.com/ethereum/go-ethereum/accounts/abi/bind" + "github.com/ethereum/go-ethereum/common" + "github.com/ethereum/go-ethereum/core/types" + "github.com/ethereum/go-ethereum/event" +) + +// Reference imports to suppress errors if they are not otherwise used. +var ( + _ = errors.New + _ = big.NewInt + _ = strings.NewReader + _ = ethereum.NotFound + _ = bind.Bind + _ = common.Big1 + _ = types.BloomLookup + _ = event.NewSubscription + _ = abi.ConvertType +) + +// ICrossChainRegistryTypesOperatorSetConfig is an auto generated low-level Go binding around an user-defined struct. +type ICrossChainRegistryTypesOperatorSetConfig struct { + Owner common.Address + MaxStalenessPeriod uint32 +} + +// IECDSACertificateVerifierTypesECDSACertificate is an auto generated low-level Go binding around an user-defined struct. +type IECDSACertificateVerifierTypesECDSACertificate struct { + ReferenceTimestamp uint32 + MessageHash [32]byte + Sig []byte +} + +// IECDSATableCalculatorTypesECDSAOperatorInfo is an auto generated low-level Go binding around an user-defined struct. +type IECDSATableCalculatorTypesECDSAOperatorInfo struct { + Pubkey common.Address + Weights []*big.Int +} + +// OperatorSet is an auto generated low-level Go binding around an user-defined struct. +type OperatorSet struct { + Avs common.Address + Id uint32 +} + +// ECDSACertificateVerifierStorageMetaData contains all meta data concerning the ECDSACertificateVerifierStorage contract. +var ECDSACertificateVerifierStorageMetaData = &bind.MetaData{ + ABI: "[{\"type\":\"function\",\"name\":\"getOperatorSetOwner\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"latestReferenceTimestamp\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maxOperatorTableStaleness\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"operatorTableUpdater\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIOperatorTableUpdater\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfos\",\"type\":\"tuple[]\",\"internalType\":\"structIECDSATableCalculatorTypes.ECDSAOperatorInfo[]\",\"components\":[{\"name\":\"pubkey\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"operatorSetConfig\",\"type\":\"tuple\",\"internalType\":\"structICrossChainRegistryTypes.OperatorSetConfig\",\"components\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificate\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"signedStakes\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificateNominal\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"totalStakeNominalThresholds\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificateProportion\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"totalStakeProportionThresholds\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"MaxStalenessPeriodUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetOwnerUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"owner\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TableUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"operatorInfos\",\"type\":\"tuple[]\",\"indexed\":false,\"internalType\":\"structIECDSATableCalculatorTypes.ECDSAOperatorInfo[]\",\"components\":[{\"name\":\"pubkey\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CertificateStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignatureLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyTableUpdater\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ReferenceTimestampDoesNotExist\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TableUpdateStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"VerificationFailed\",\"inputs\":[]}]", +} + +// ECDSACertificateVerifierStorageABI is the input ABI used to generate the binding from. +// Deprecated: Use ECDSACertificateVerifierStorageMetaData.ABI instead. +var ECDSACertificateVerifierStorageABI = ECDSACertificateVerifierStorageMetaData.ABI + +// ECDSACertificateVerifierStorage is an auto generated Go binding around an Ethereum contract. +type ECDSACertificateVerifierStorage struct { + ECDSACertificateVerifierStorageCaller // Read-only binding to the contract + ECDSACertificateVerifierStorageTransactor // Write-only binding to the contract + ECDSACertificateVerifierStorageFilterer // Log filterer for contract events +} + +// ECDSACertificateVerifierStorageCaller is an auto generated read-only Go binding around an Ethereum contract. +type ECDSACertificateVerifierStorageCaller struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ECDSACertificateVerifierStorageTransactor is an auto generated write-only Go binding around an Ethereum contract. +type ECDSACertificateVerifierStorageTransactor struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ECDSACertificateVerifierStorageFilterer is an auto generated log filtering Go binding around an Ethereum contract events. +type ECDSACertificateVerifierStorageFilterer struct { + contract *bind.BoundContract // Generic contract wrapper for the low level calls +} + +// ECDSACertificateVerifierStorageSession is an auto generated Go binding around an Ethereum contract, +// with pre-set call and transact options. +type ECDSACertificateVerifierStorageSession struct { + Contract *ECDSACertificateVerifierStorage // Generic contract binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ECDSACertificateVerifierStorageCallerSession is an auto generated read-only Go binding around an Ethereum contract, +// with pre-set call options. +type ECDSACertificateVerifierStorageCallerSession struct { + Contract *ECDSACertificateVerifierStorageCaller // Generic contract caller binding to set the session for + CallOpts bind.CallOpts // Call options to use throughout this session +} + +// ECDSACertificateVerifierStorageTransactorSession is an auto generated write-only Go binding around an Ethereum contract, +// with pre-set transact options. +type ECDSACertificateVerifierStorageTransactorSession struct { + Contract *ECDSACertificateVerifierStorageTransactor // Generic contract transactor binding to set the session for + TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session +} + +// ECDSACertificateVerifierStorageRaw is an auto generated low-level Go binding around an Ethereum contract. +type ECDSACertificateVerifierStorageRaw struct { + Contract *ECDSACertificateVerifierStorage // Generic contract binding to access the raw methods on +} + +// ECDSACertificateVerifierStorageCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. +type ECDSACertificateVerifierStorageCallerRaw struct { + Contract *ECDSACertificateVerifierStorageCaller // Generic read-only contract binding to access the raw methods on +} + +// ECDSACertificateVerifierStorageTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. +type ECDSACertificateVerifierStorageTransactorRaw struct { + Contract *ECDSACertificateVerifierStorageTransactor // Generic write-only contract binding to access the raw methods on +} + +// NewECDSACertificateVerifierStorage creates a new instance of ECDSACertificateVerifierStorage, bound to a specific deployed contract. +func NewECDSACertificateVerifierStorage(address common.Address, backend bind.ContractBackend) (*ECDSACertificateVerifierStorage, error) { + contract, err := bindECDSACertificateVerifierStorage(address, backend, backend, backend) + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierStorage{ECDSACertificateVerifierStorageCaller: ECDSACertificateVerifierStorageCaller{contract: contract}, ECDSACertificateVerifierStorageTransactor: ECDSACertificateVerifierStorageTransactor{contract: contract}, ECDSACertificateVerifierStorageFilterer: ECDSACertificateVerifierStorageFilterer{contract: contract}}, nil +} + +// NewECDSACertificateVerifierStorageCaller creates a new read-only instance of ECDSACertificateVerifierStorage, bound to a specific deployed contract. +func NewECDSACertificateVerifierStorageCaller(address common.Address, caller bind.ContractCaller) (*ECDSACertificateVerifierStorageCaller, error) { + contract, err := bindECDSACertificateVerifierStorage(address, caller, nil, nil) + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierStorageCaller{contract: contract}, nil +} + +// NewECDSACertificateVerifierStorageTransactor creates a new write-only instance of ECDSACertificateVerifierStorage, bound to a specific deployed contract. +func NewECDSACertificateVerifierStorageTransactor(address common.Address, transactor bind.ContractTransactor) (*ECDSACertificateVerifierStorageTransactor, error) { + contract, err := bindECDSACertificateVerifierStorage(address, nil, transactor, nil) + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierStorageTransactor{contract: contract}, nil +} + +// NewECDSACertificateVerifierStorageFilterer creates a new log filterer instance of ECDSACertificateVerifierStorage, bound to a specific deployed contract. +func NewECDSACertificateVerifierStorageFilterer(address common.Address, filterer bind.ContractFilterer) (*ECDSACertificateVerifierStorageFilterer, error) { + contract, err := bindECDSACertificateVerifierStorage(address, nil, nil, filterer) + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierStorageFilterer{contract: contract}, nil +} + +// bindECDSACertificateVerifierStorage binds a generic wrapper to an already deployed contract. +func bindECDSACertificateVerifierStorage(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { + parsed, err := ECDSACertificateVerifierStorageMetaData.GetAbi() + if err != nil { + return nil, err + } + return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ECDSACertificateVerifierStorage.Contract.ECDSACertificateVerifierStorageCaller.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.ECDSACertificateVerifierStorageTransactor.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.ECDSACertificateVerifierStorageTransactor.contract.Transact(opts, method, params...) +} + +// Call invokes the (constant) contract method with params as input values and +// sets the output to result. The result type might be a single field for simple +// returns, a slice of interfaces for anonymous returns and a struct for named +// returns. +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error { + return _ECDSACertificateVerifierStorage.Contract.contract.Call(opts, result, method, params...) +} + +// Transfer initiates a plain transaction to move funds to the contract, calling +// its default method if one is available. +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.contract.Transfer(opts) +} + +// Transact invokes the (paid) contract method with params as input values. +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.contract.Transact(opts, method, params...) +} + +// GetOperatorSetOwner is a free data retrieval call binding the contract method 0x84818920. +// +// Solidity: function getOperatorSetOwner((address,uint32) operatorSet) view returns(address) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageCaller) GetOperatorSetOwner(opts *bind.CallOpts, operatorSet OperatorSet) (common.Address, error) { + var out []interface{} + err := _ECDSACertificateVerifierStorage.contract.Call(opts, &out, "getOperatorSetOwner", operatorSet) + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// GetOperatorSetOwner is a free data retrieval call binding the contract method 0x84818920. +// +// Solidity: function getOperatorSetOwner((address,uint32) operatorSet) view returns(address) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageSession) GetOperatorSetOwner(operatorSet OperatorSet) (common.Address, error) { + return _ECDSACertificateVerifierStorage.Contract.GetOperatorSetOwner(&_ECDSACertificateVerifierStorage.CallOpts, operatorSet) +} + +// GetOperatorSetOwner is a free data retrieval call binding the contract method 0x84818920. +// +// Solidity: function getOperatorSetOwner((address,uint32) operatorSet) view returns(address) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageCallerSession) GetOperatorSetOwner(operatorSet OperatorSet) (common.Address, error) { + return _ECDSACertificateVerifierStorage.Contract.GetOperatorSetOwner(&_ECDSACertificateVerifierStorage.CallOpts, operatorSet) +} + +// LatestReferenceTimestamp is a free data retrieval call binding the contract method 0x5ddb9b5b. +// +// Solidity: function latestReferenceTimestamp((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageCaller) LatestReferenceTimestamp(opts *bind.CallOpts, operatorSet OperatorSet) (uint32, error) { + var out []interface{} + err := _ECDSACertificateVerifierStorage.contract.Call(opts, &out, "latestReferenceTimestamp", operatorSet) + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// LatestReferenceTimestamp is a free data retrieval call binding the contract method 0x5ddb9b5b. +// +// Solidity: function latestReferenceTimestamp((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageSession) LatestReferenceTimestamp(operatorSet OperatorSet) (uint32, error) { + return _ECDSACertificateVerifierStorage.Contract.LatestReferenceTimestamp(&_ECDSACertificateVerifierStorage.CallOpts, operatorSet) +} + +// LatestReferenceTimestamp is a free data retrieval call binding the contract method 0x5ddb9b5b. +// +// Solidity: function latestReferenceTimestamp((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageCallerSession) LatestReferenceTimestamp(operatorSet OperatorSet) (uint32, error) { + return _ECDSACertificateVerifierStorage.Contract.LatestReferenceTimestamp(&_ECDSACertificateVerifierStorage.CallOpts, operatorSet) +} + +// MaxOperatorTableStaleness is a free data retrieval call binding the contract method 0x6141879e. +// +// Solidity: function maxOperatorTableStaleness((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageCaller) MaxOperatorTableStaleness(opts *bind.CallOpts, operatorSet OperatorSet) (uint32, error) { + var out []interface{} + err := _ECDSACertificateVerifierStorage.contract.Call(opts, &out, "maxOperatorTableStaleness", operatorSet) + + if err != nil { + return *new(uint32), err + } + + out0 := *abi.ConvertType(out[0], new(uint32)).(*uint32) + + return out0, err + +} + +// MaxOperatorTableStaleness is a free data retrieval call binding the contract method 0x6141879e. +// +// Solidity: function maxOperatorTableStaleness((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageSession) MaxOperatorTableStaleness(operatorSet OperatorSet) (uint32, error) { + return _ECDSACertificateVerifierStorage.Contract.MaxOperatorTableStaleness(&_ECDSACertificateVerifierStorage.CallOpts, operatorSet) +} + +// MaxOperatorTableStaleness is a free data retrieval call binding the contract method 0x6141879e. +// +// Solidity: function maxOperatorTableStaleness((address,uint32) operatorSet) view returns(uint32) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageCallerSession) MaxOperatorTableStaleness(operatorSet OperatorSet) (uint32, error) { + return _ECDSACertificateVerifierStorage.Contract.MaxOperatorTableStaleness(&_ECDSACertificateVerifierStorage.CallOpts, operatorSet) +} + +// OperatorTableUpdater is a free data retrieval call binding the contract method 0x68d6e081. +// +// Solidity: function operatorTableUpdater() view returns(address) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageCaller) OperatorTableUpdater(opts *bind.CallOpts) (common.Address, error) { + var out []interface{} + err := _ECDSACertificateVerifierStorage.contract.Call(opts, &out, "operatorTableUpdater") + + if err != nil { + return *new(common.Address), err + } + + out0 := *abi.ConvertType(out[0], new(common.Address)).(*common.Address) + + return out0, err + +} + +// OperatorTableUpdater is a free data retrieval call binding the contract method 0x68d6e081. +// +// Solidity: function operatorTableUpdater() view returns(address) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageSession) OperatorTableUpdater() (common.Address, error) { + return _ECDSACertificateVerifierStorage.Contract.OperatorTableUpdater(&_ECDSACertificateVerifierStorage.CallOpts) +} + +// OperatorTableUpdater is a free data retrieval call binding the contract method 0x68d6e081. +// +// Solidity: function operatorTableUpdater() view returns(address) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageCallerSession) OperatorTableUpdater() (common.Address, error) { + return _ECDSACertificateVerifierStorage.Contract.OperatorTableUpdater(&_ECDSACertificateVerifierStorage.CallOpts) +} + +// UpdateOperatorTable is a paid mutator transaction binding the contract method 0x56d482f5. +// +// Solidity: function updateOperatorTable((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos, (address,uint32) operatorSetConfig) returns() +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageTransactor) UpdateOperatorTable(opts *bind.TransactOpts, operatorSet OperatorSet, referenceTimestamp uint32, operatorInfos []IECDSATableCalculatorTypesECDSAOperatorInfo, operatorSetConfig ICrossChainRegistryTypesOperatorSetConfig) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.contract.Transact(opts, "updateOperatorTable", operatorSet, referenceTimestamp, operatorInfos, operatorSetConfig) +} + +// UpdateOperatorTable is a paid mutator transaction binding the contract method 0x56d482f5. +// +// Solidity: function updateOperatorTable((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos, (address,uint32) operatorSetConfig) returns() +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageSession) UpdateOperatorTable(operatorSet OperatorSet, referenceTimestamp uint32, operatorInfos []IECDSATableCalculatorTypesECDSAOperatorInfo, operatorSetConfig ICrossChainRegistryTypesOperatorSetConfig) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.UpdateOperatorTable(&_ECDSACertificateVerifierStorage.TransactOpts, operatorSet, referenceTimestamp, operatorInfos, operatorSetConfig) +} + +// UpdateOperatorTable is a paid mutator transaction binding the contract method 0x56d482f5. +// +// Solidity: function updateOperatorTable((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos, (address,uint32) operatorSetConfig) returns() +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageTransactorSession) UpdateOperatorTable(operatorSet OperatorSet, referenceTimestamp uint32, operatorInfos []IECDSATableCalculatorTypesECDSAOperatorInfo, operatorSetConfig ICrossChainRegistryTypesOperatorSetConfig) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.UpdateOperatorTable(&_ECDSACertificateVerifierStorage.TransactOpts, operatorSet, referenceTimestamp, operatorInfos, operatorSetConfig) +} + +// VerifyCertificate is a paid mutator transaction binding the contract method 0x80c7d3f3. +// +// Solidity: function verifyCertificate((address,uint32) operatorSet, (uint32,bytes32,bytes) cert) returns(uint256[] signedStakes) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageTransactor) VerifyCertificate(opts *bind.TransactOpts, operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.contract.Transact(opts, "verifyCertificate", operatorSet, cert) +} + +// VerifyCertificate is a paid mutator transaction binding the contract method 0x80c7d3f3. +// +// Solidity: function verifyCertificate((address,uint32) operatorSet, (uint32,bytes32,bytes) cert) returns(uint256[] signedStakes) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageSession) VerifyCertificate(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.VerifyCertificate(&_ECDSACertificateVerifierStorage.TransactOpts, operatorSet, cert) +} + +// VerifyCertificate is a paid mutator transaction binding the contract method 0x80c7d3f3. +// +// Solidity: function verifyCertificate((address,uint32) operatorSet, (uint32,bytes32,bytes) cert) returns(uint256[] signedStakes) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageTransactorSession) VerifyCertificate(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.VerifyCertificate(&_ECDSACertificateVerifierStorage.TransactOpts, operatorSet, cert) +} + +// VerifyCertificateNominal is a paid mutator transaction binding the contract method 0xbe86e0b2. +// +// Solidity: function verifyCertificateNominal((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint256[] totalStakeNominalThresholds) returns(bool) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageTransactor) VerifyCertificateNominal(opts *bind.TransactOpts, operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeNominalThresholds []*big.Int) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.contract.Transact(opts, "verifyCertificateNominal", operatorSet, cert, totalStakeNominalThresholds) +} + +// VerifyCertificateNominal is a paid mutator transaction binding the contract method 0xbe86e0b2. +// +// Solidity: function verifyCertificateNominal((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint256[] totalStakeNominalThresholds) returns(bool) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageSession) VerifyCertificateNominal(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeNominalThresholds []*big.Int) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.VerifyCertificateNominal(&_ECDSACertificateVerifierStorage.TransactOpts, operatorSet, cert, totalStakeNominalThresholds) +} + +// VerifyCertificateNominal is a paid mutator transaction binding the contract method 0xbe86e0b2. +// +// Solidity: function verifyCertificateNominal((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint256[] totalStakeNominalThresholds) returns(bool) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageTransactorSession) VerifyCertificateNominal(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeNominalThresholds []*big.Int) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.VerifyCertificateNominal(&_ECDSACertificateVerifierStorage.TransactOpts, operatorSet, cert, totalStakeNominalThresholds) +} + +// VerifyCertificateProportion is a paid mutator transaction binding the contract method 0xc0da2420. +// +// Solidity: function verifyCertificateProportion((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint16[] totalStakeProportionThresholds) returns(bool) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageTransactor) VerifyCertificateProportion(opts *bind.TransactOpts, operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeProportionThresholds []uint16) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.contract.Transact(opts, "verifyCertificateProportion", operatorSet, cert, totalStakeProportionThresholds) +} + +// VerifyCertificateProportion is a paid mutator transaction binding the contract method 0xc0da2420. +// +// Solidity: function verifyCertificateProportion((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint16[] totalStakeProportionThresholds) returns(bool) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageSession) VerifyCertificateProportion(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeProportionThresholds []uint16) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.VerifyCertificateProportion(&_ECDSACertificateVerifierStorage.TransactOpts, operatorSet, cert, totalStakeProportionThresholds) +} + +// VerifyCertificateProportion is a paid mutator transaction binding the contract method 0xc0da2420. +// +// Solidity: function verifyCertificateProportion((address,uint32) operatorSet, (uint32,bytes32,bytes) cert, uint16[] totalStakeProportionThresholds) returns(bool) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageTransactorSession) VerifyCertificateProportion(operatorSet OperatorSet, cert IECDSACertificateVerifierTypesECDSACertificate, totalStakeProportionThresholds []uint16) (*types.Transaction, error) { + return _ECDSACertificateVerifierStorage.Contract.VerifyCertificateProportion(&_ECDSACertificateVerifierStorage.TransactOpts, operatorSet, cert, totalStakeProportionThresholds) +} + +// ECDSACertificateVerifierStorageMaxStalenessPeriodUpdatedIterator is returned from FilterMaxStalenessPeriodUpdated and is used to iterate over the raw logs and unpacked data for MaxStalenessPeriodUpdated events raised by the ECDSACertificateVerifierStorage contract. +type ECDSACertificateVerifierStorageMaxStalenessPeriodUpdatedIterator struct { + Event *ECDSACertificateVerifierStorageMaxStalenessPeriodUpdated // 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 *ECDSACertificateVerifierStorageMaxStalenessPeriodUpdatedIterator) 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(ECDSACertificateVerifierStorageMaxStalenessPeriodUpdated) + 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(ECDSACertificateVerifierStorageMaxStalenessPeriodUpdated) + 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 *ECDSACertificateVerifierStorageMaxStalenessPeriodUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ECDSACertificateVerifierStorageMaxStalenessPeriodUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ECDSACertificateVerifierStorageMaxStalenessPeriodUpdated represents a MaxStalenessPeriodUpdated event raised by the ECDSACertificateVerifierStorage contract. +type ECDSACertificateVerifierStorageMaxStalenessPeriodUpdated struct { + OperatorSet OperatorSet + MaxStalenessPeriod uint32 + Raw types.Log // Blockchain specific contextual infos +} + +// FilterMaxStalenessPeriodUpdated is a free log retrieval operation binding the contract event 0x28539469fbbc8a5482e60966bf9376f7b9d25b2f0a65a9976f6baa3f0e3788da. +// +// Solidity: event MaxStalenessPeriodUpdated((address,uint32) operatorSet, uint32 maxStalenessPeriod) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageFilterer) FilterMaxStalenessPeriodUpdated(opts *bind.FilterOpts) (*ECDSACertificateVerifierStorageMaxStalenessPeriodUpdatedIterator, error) { + + logs, sub, err := _ECDSACertificateVerifierStorage.contract.FilterLogs(opts, "MaxStalenessPeriodUpdated") + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierStorageMaxStalenessPeriodUpdatedIterator{contract: _ECDSACertificateVerifierStorage.contract, event: "MaxStalenessPeriodUpdated", logs: logs, sub: sub}, nil +} + +// WatchMaxStalenessPeriodUpdated is a free log subscription operation binding the contract event 0x28539469fbbc8a5482e60966bf9376f7b9d25b2f0a65a9976f6baa3f0e3788da. +// +// Solidity: event MaxStalenessPeriodUpdated((address,uint32) operatorSet, uint32 maxStalenessPeriod) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageFilterer) WatchMaxStalenessPeriodUpdated(opts *bind.WatchOpts, sink chan<- *ECDSACertificateVerifierStorageMaxStalenessPeriodUpdated) (event.Subscription, error) { + + logs, sub, err := _ECDSACertificateVerifierStorage.contract.WatchLogs(opts, "MaxStalenessPeriodUpdated") + 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(ECDSACertificateVerifierStorageMaxStalenessPeriodUpdated) + if err := _ECDSACertificateVerifierStorage.contract.UnpackLog(event, "MaxStalenessPeriodUpdated", 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 +} + +// ParseMaxStalenessPeriodUpdated is a log parse operation binding the contract event 0x28539469fbbc8a5482e60966bf9376f7b9d25b2f0a65a9976f6baa3f0e3788da. +// +// Solidity: event MaxStalenessPeriodUpdated((address,uint32) operatorSet, uint32 maxStalenessPeriod) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageFilterer) ParseMaxStalenessPeriodUpdated(log types.Log) (*ECDSACertificateVerifierStorageMaxStalenessPeriodUpdated, error) { + event := new(ECDSACertificateVerifierStorageMaxStalenessPeriodUpdated) + if err := _ECDSACertificateVerifierStorage.contract.UnpackLog(event, "MaxStalenessPeriodUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ECDSACertificateVerifierStorageOperatorSetOwnerUpdatedIterator is returned from FilterOperatorSetOwnerUpdated and is used to iterate over the raw logs and unpacked data for OperatorSetOwnerUpdated events raised by the ECDSACertificateVerifierStorage contract. +type ECDSACertificateVerifierStorageOperatorSetOwnerUpdatedIterator struct { + Event *ECDSACertificateVerifierStorageOperatorSetOwnerUpdated // 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 *ECDSACertificateVerifierStorageOperatorSetOwnerUpdatedIterator) 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(ECDSACertificateVerifierStorageOperatorSetOwnerUpdated) + 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(ECDSACertificateVerifierStorageOperatorSetOwnerUpdated) + 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 *ECDSACertificateVerifierStorageOperatorSetOwnerUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ECDSACertificateVerifierStorageOperatorSetOwnerUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ECDSACertificateVerifierStorageOperatorSetOwnerUpdated represents a OperatorSetOwnerUpdated event raised by the ECDSACertificateVerifierStorage contract. +type ECDSACertificateVerifierStorageOperatorSetOwnerUpdated struct { + OperatorSet OperatorSet + Owner common.Address + Raw types.Log // Blockchain specific contextual infos +} + +// FilterOperatorSetOwnerUpdated is a free log retrieval operation binding the contract event 0x806dc367095c0baf953d7144b7c4376261675ee0b4e0da2761e43673051c7375. +// +// Solidity: event OperatorSetOwnerUpdated((address,uint32) operatorSet, address owner) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageFilterer) FilterOperatorSetOwnerUpdated(opts *bind.FilterOpts) (*ECDSACertificateVerifierStorageOperatorSetOwnerUpdatedIterator, error) { + + logs, sub, err := _ECDSACertificateVerifierStorage.contract.FilterLogs(opts, "OperatorSetOwnerUpdated") + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierStorageOperatorSetOwnerUpdatedIterator{contract: _ECDSACertificateVerifierStorage.contract, event: "OperatorSetOwnerUpdated", logs: logs, sub: sub}, nil +} + +// WatchOperatorSetOwnerUpdated is a free log subscription operation binding the contract event 0x806dc367095c0baf953d7144b7c4376261675ee0b4e0da2761e43673051c7375. +// +// Solidity: event OperatorSetOwnerUpdated((address,uint32) operatorSet, address owner) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageFilterer) WatchOperatorSetOwnerUpdated(opts *bind.WatchOpts, sink chan<- *ECDSACertificateVerifierStorageOperatorSetOwnerUpdated) (event.Subscription, error) { + + logs, sub, err := _ECDSACertificateVerifierStorage.contract.WatchLogs(opts, "OperatorSetOwnerUpdated") + 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(ECDSACertificateVerifierStorageOperatorSetOwnerUpdated) + if err := _ECDSACertificateVerifierStorage.contract.UnpackLog(event, "OperatorSetOwnerUpdated", 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 +} + +// ParseOperatorSetOwnerUpdated is a log parse operation binding the contract event 0x806dc367095c0baf953d7144b7c4376261675ee0b4e0da2761e43673051c7375. +// +// Solidity: event OperatorSetOwnerUpdated((address,uint32) operatorSet, address owner) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageFilterer) ParseOperatorSetOwnerUpdated(log types.Log) (*ECDSACertificateVerifierStorageOperatorSetOwnerUpdated, error) { + event := new(ECDSACertificateVerifierStorageOperatorSetOwnerUpdated) + if err := _ECDSACertificateVerifierStorage.contract.UnpackLog(event, "OperatorSetOwnerUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} + +// ECDSACertificateVerifierStorageTableUpdatedIterator is returned from FilterTableUpdated and is used to iterate over the raw logs and unpacked data for TableUpdated events raised by the ECDSACertificateVerifierStorage contract. +type ECDSACertificateVerifierStorageTableUpdatedIterator struct { + Event *ECDSACertificateVerifierStorageTableUpdated // 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 *ECDSACertificateVerifierStorageTableUpdatedIterator) 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(ECDSACertificateVerifierStorageTableUpdated) + 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(ECDSACertificateVerifierStorageTableUpdated) + 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 *ECDSACertificateVerifierStorageTableUpdatedIterator) Error() error { + return it.fail +} + +// Close terminates the iteration process, releasing any pending underlying +// resources. +func (it *ECDSACertificateVerifierStorageTableUpdatedIterator) Close() error { + it.sub.Unsubscribe() + return nil +} + +// ECDSACertificateVerifierStorageTableUpdated represents a TableUpdated event raised by the ECDSACertificateVerifierStorage contract. +type ECDSACertificateVerifierStorageTableUpdated struct { + OperatorSet OperatorSet + ReferenceTimestamp uint32 + OperatorInfos []IECDSATableCalculatorTypesECDSAOperatorInfo + Raw types.Log // Blockchain specific contextual infos +} + +// FilterTableUpdated is a free log retrieval operation binding the contract event 0x4f588da9ec57976194a79b5594f8f8782923d93013df2b9ed12fe125805011ef. +// +// Solidity: event TableUpdated((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageFilterer) FilterTableUpdated(opts *bind.FilterOpts) (*ECDSACertificateVerifierStorageTableUpdatedIterator, error) { + + logs, sub, err := _ECDSACertificateVerifierStorage.contract.FilterLogs(opts, "TableUpdated") + if err != nil { + return nil, err + } + return &ECDSACertificateVerifierStorageTableUpdatedIterator{contract: _ECDSACertificateVerifierStorage.contract, event: "TableUpdated", logs: logs, sub: sub}, nil +} + +// WatchTableUpdated is a free log subscription operation binding the contract event 0x4f588da9ec57976194a79b5594f8f8782923d93013df2b9ed12fe125805011ef. +// +// Solidity: event TableUpdated((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageFilterer) WatchTableUpdated(opts *bind.WatchOpts, sink chan<- *ECDSACertificateVerifierStorageTableUpdated) (event.Subscription, error) { + + logs, sub, err := _ECDSACertificateVerifierStorage.contract.WatchLogs(opts, "TableUpdated") + 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(ECDSACertificateVerifierStorageTableUpdated) + if err := _ECDSACertificateVerifierStorage.contract.UnpackLog(event, "TableUpdated", 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 +} + +// ParseTableUpdated is a log parse operation binding the contract event 0x4f588da9ec57976194a79b5594f8f8782923d93013df2b9ed12fe125805011ef. +// +// Solidity: event TableUpdated((address,uint32) operatorSet, uint32 referenceTimestamp, (address,uint256[])[] operatorInfos) +func (_ECDSACertificateVerifierStorage *ECDSACertificateVerifierStorageFilterer) ParseTableUpdated(log types.Log) (*ECDSACertificateVerifierStorageTableUpdated, error) { + event := new(ECDSACertificateVerifierStorageTableUpdated) + if err := _ECDSACertificateVerifierStorage.contract.UnpackLog(event, "TableUpdated", log); err != nil { + return nil, err + } + event.Raw = log + return event, nil +} diff --git a/pkg/bindings/IECDSACertificateVerifier/binding.go b/pkg/bindings/IECDSACertificateVerifier/binding.go index 6854f27ef0..a3dccd972f 100644 --- a/pkg/bindings/IECDSACertificateVerifier/binding.go +++ b/pkg/bindings/IECDSACertificateVerifier/binding.go @@ -56,7 +56,7 @@ type OperatorSet struct { // IECDSACertificateVerifierMetaData contains all meta data concerning the IECDSACertificateVerifier contract. var IECDSACertificateVerifierMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"getOperatorSetOwner\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"latestReferenceTimestamp\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maxOperatorTableStaleness\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfos\",\"type\":\"tuple[]\",\"internalType\":\"structIECDSATableCalculatorTypes.ECDSAOperatorInfo[]\",\"components\":[{\"name\":\"pubkey\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"operatorSetConfig\",\"type\":\"tuple\",\"internalType\":\"structICrossChainRegistryTypes.OperatorSetConfig\",\"components\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificate\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"signedStakes\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificateNominal\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"totalStakeNominalThresholds\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificateProportion\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"totalStakeProportionThresholds\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"MaxStalenessPeriodUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetOwnerUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"owner\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TableUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"operatorInfos\",\"type\":\"tuple[]\",\"indexed\":false,\"internalType\":\"structIECDSATableCalculatorTypes.ECDSAOperatorInfo[]\",\"components\":[{\"name\":\"pubkey\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CertificateStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyTableUpdater\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ReferenceTimestampDoesNotExist\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TableUpdateStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"VerificationFailed\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"getOperatorSetOwner\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"latestReferenceTimestamp\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"maxOperatorTableStaleness\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfos\",\"type\":\"tuple[]\",\"internalType\":\"structIECDSATableCalculatorTypes.ECDSAOperatorInfo[]\",\"components\":[{\"name\":\"pubkey\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"operatorSetConfig\",\"type\":\"tuple\",\"internalType\":\"structICrossChainRegistryTypes.OperatorSetConfig\",\"components\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificate\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]}],\"outputs\":[{\"name\":\"signedStakes\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificateNominal\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"totalStakeNominalThresholds\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"verifyCertificateProportion\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"cert\",\"type\":\"tuple\",\"internalType\":\"structIECDSACertificateVerifierTypes.ECDSACertificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"sig\",\"type\":\"bytes\",\"internalType\":\"bytes\"}]},{\"name\":\"totalStakeProportionThresholds\",\"type\":\"uint16[]\",\"internalType\":\"uint16[]\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bool\",\"internalType\":\"bool\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"MaxStalenessPeriodUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"OperatorSetOwnerUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"owner\",\"type\":\"address\",\"indexed\":false,\"internalType\":\"address\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"TableUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":false,\"internalType\":\"uint32\"},{\"name\":\"operatorInfos\",\"type\":\"tuple[]\",\"indexed\":false,\"internalType\":\"structIECDSATableCalculatorTypes.ECDSAOperatorInfo[]\",\"components\":[{\"name\":\"pubkey\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"ArrayLengthMismatch\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"CertificateStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignatureLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"OnlyTableUpdater\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"ReferenceTimestampDoesNotExist\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TableUpdateStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"VerificationFailed\",\"inputs\":[]}]", } // IECDSACertificateVerifierABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/IOperatorTableUpdater/binding.go b/pkg/bindings/IOperatorTableUpdater/binding.go index dfe4a44648..6587878d75 100644 --- a/pkg/bindings/IOperatorTableUpdater/binding.go +++ b/pkg/bindings/IOperatorTableUpdater/binding.go @@ -71,7 +71,7 @@ type OperatorSet struct { // IOperatorTableUpdaterMetaData contains all meta data concerning the IOperatorTableUpdater contract. var IOperatorTableUpdaterMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"confirmGlobalTableRoot\",\"inputs\":[{\"name\":\"globalTableRootCert\",\"type\":\"tuple\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254Certificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"apk\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"nonSignerWitnesses\",\"type\":\"tuple[]\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254OperatorInfoWitness[]\",\"components\":[{\"name\":\"operatorIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfoProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorInfo\",\"components\":[{\"name\":\"pubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}]}]},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getCertificateVerifier\",\"inputs\":[{\"name\":\"curveType\",\"type\":\"uint8\",\"internalType\":\"enumIKeyRegistrarTypes.CurveType\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentGlobalTableRoot\",\"inputs\":[],\"outputs\":[{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalConfirmerSetReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalRootConfirmerSet\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableRootByTimestamp\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"tableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableUpdateMessageHash\",\"inputs\":[{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getLatestReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmationThreshold\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmerSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"operatorSetIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorTableBytes\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"GlobalRootConfirmationThresholdUpdated\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"GlobalRootConfirmerSetUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewGlobalTableRoot\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":true,\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CertificateInvalid\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootInFuture\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidConfirmationThreshold\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCurveType\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidGlobalTableRoot\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidMessageHash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSetProof\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TableUpdateForPastTimestamp\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"confirmGlobalTableRoot\",\"inputs\":[{\"name\":\"globalTableRootCert\",\"type\":\"tuple\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254Certificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"apk\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"nonSignerWitnesses\",\"type\":\"tuple[]\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254OperatorInfoWitness[]\",\"components\":[{\"name\":\"operatorIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfoProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorInfo\",\"components\":[{\"name\":\"pubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}]}]},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"getCertificateVerifier\",\"inputs\":[{\"name\":\"curveType\",\"type\":\"uint8\",\"internalType\":\"enumIKeyRegistrarTypes.CurveType\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentGlobalTableRoot\",\"inputs\":[],\"outputs\":[{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalConfirmerSetReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalRootConfirmerSet\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableRootByTimestamp\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"tableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableUpdateMessageHash\",\"inputs\":[{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getLatestReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmationThreshold\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmerSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"operatorSetIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorTableBytes\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"GlobalRootConfirmationThresholdUpdated\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"GlobalRootConfirmerSetUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewGlobalTableRoot\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":true,\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CertificateInvalid\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootInFuture\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidConfirmationThreshold\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCurveType\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidGlobalTableRoot\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidMessageHash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSetProof\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignatureLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TableUpdateForPastTimestamp\",\"inputs\":[]}]", } // IOperatorTableUpdaterABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/OperatorTableUpdater/binding.go b/pkg/bindings/OperatorTableUpdater/binding.go index 05a789cd9c..25158b27b4 100644 --- a/pkg/bindings/OperatorTableUpdater/binding.go +++ b/pkg/bindings/OperatorTableUpdater/binding.go @@ -85,8 +85,8 @@ type OperatorSet struct { // OperatorTableUpdaterMetaData contains all meta data concerning the OperatorTableUpdater contract. var OperatorTableUpdaterMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_bn254CertificateVerifier\",\"type\":\"address\",\"internalType\":\"contractIBN254CertificateVerifier\"},{\"name\":\"_ecdsaCertificateVerifier\",\"type\":\"address\",\"internalType\":\"contractIECDSACertificateVerifier\"},{\"name\":\"_version\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"GLOBAL_TABLE_ROOT_CERT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"MAX_BPS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"bn254CertificateVerifier\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBN254CertificateVerifier\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"confirmGlobalTableRoot\",\"inputs\":[{\"name\":\"globalTableRootCert\",\"type\":\"tuple\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254Certificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"apk\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"nonSignerWitnesses\",\"type\":\"tuple[]\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254OperatorInfoWitness[]\",\"components\":[{\"name\":\"operatorIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfoProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorInfo\",\"components\":[{\"name\":\"pubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}]}]},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"ecdsaCertificateVerifier\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIECDSACertificateVerifier\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCertificateVerifier\",\"inputs\":[{\"name\":\"curveType\",\"type\":\"uint8\",\"internalType\":\"enumIKeyRegistrarTypes.CurveType\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentGlobalTableRoot\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalConfirmerSetReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalRootConfirmerSet\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableRootByTimestamp\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableUpdateMessageHash\",\"inputs\":[{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"getLatestReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"globalRootConfirmationThreshold\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_globalRootConfirmerSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"_globalRootConfirmationThreshold\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"globalRootConfirmerSetInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorSetInfo\",\"components\":[{\"name\":\"operatorInfoTreeRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"numOperators\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"aggregatePubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"totalWeights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"globalRootConfirmerSetConfig\",\"type\":\"tuple\",\"internalType\":\"structICrossChainRegistryTypes.OperatorSetConfig\",\"components\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmationThreshold\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmerSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"operatorSetIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorTableBytes\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"GlobalRootConfirmationThresholdUpdated\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"GlobalRootConfirmerSetUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewGlobalTableRoot\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":true,\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"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\":\"error\",\"name\":\"CertificateInvalid\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootInFuture\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidConfirmationThreshold\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCurveType\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidGlobalTableRoot\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidMessageHash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSetProof\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidProofLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidShortString\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StringTooLong\",\"inputs\":[{\"name\":\"str\",\"type\":\"string\",\"internalType\":\"string\"}]},{\"type\":\"error\",\"name\":\"TableUpdateForPastTimestamp\",\"inputs\":[]}]", - Bin: "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", + ABI: "[{\"type\":\"constructor\",\"inputs\":[{\"name\":\"_bn254CertificateVerifier\",\"type\":\"address\",\"internalType\":\"contractIBN254CertificateVerifier\"},{\"name\":\"_ecdsaCertificateVerifier\",\"type\":\"address\",\"internalType\":\"contractIECDSACertificateVerifier\"},{\"name\":\"_version\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"GLOBAL_TABLE_ROOT_CERT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"MAX_BPS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"bn254CertificateVerifier\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBN254CertificateVerifier\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"confirmGlobalTableRoot\",\"inputs\":[{\"name\":\"globalTableRootCert\",\"type\":\"tuple\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254Certificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"apk\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"nonSignerWitnesses\",\"type\":\"tuple[]\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254OperatorInfoWitness[]\",\"components\":[{\"name\":\"operatorIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfoProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorInfo\",\"components\":[{\"name\":\"pubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}]}]},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"ecdsaCertificateVerifier\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIECDSACertificateVerifier\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCertificateVerifier\",\"inputs\":[{\"name\":\"curveType\",\"type\":\"uint8\",\"internalType\":\"enumIKeyRegistrarTypes.CurveType\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentGlobalTableRoot\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalConfirmerSetReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalRootConfirmerSet\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableRootByTimestamp\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableUpdateMessageHash\",\"inputs\":[{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"pure\"},{\"type\":\"function\",\"name\":\"getLatestReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"globalRootConfirmationThreshold\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"initialize\",\"inputs\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"_globalRootConfirmerSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]},{\"name\":\"_globalRootConfirmationThreshold\",\"type\":\"uint16\",\"internalType\":\"uint16\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"globalRootConfirmerSetInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorSetInfo\",\"components\":[{\"name\":\"operatorInfoTreeRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"numOperators\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"aggregatePubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"totalWeights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]},{\"name\":\"globalRootConfirmerSetConfig\",\"type\":\"tuple\",\"internalType\":\"structICrossChainRegistryTypes.OperatorSetConfig\",\"components\":[{\"name\":\"owner\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"maxStalenessPeriod\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"owner\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"renounceOwnership\",\"inputs\":[],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmationThreshold\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmerSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"transferOwnership\",\"inputs\":[{\"name\":\"newOwner\",\"type\":\"address\",\"internalType\":\"address\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"operatorSetIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorTableBytes\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"version\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"string\",\"internalType\":\"string\"}],\"stateMutability\":\"view\"},{\"type\":\"event\",\"name\":\"GlobalRootConfirmationThresholdUpdated\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"GlobalRootConfirmerSetUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"Initialized\",\"inputs\":[{\"name\":\"version\",\"type\":\"uint8\",\"indexed\":false,\"internalType\":\"uint8\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewGlobalTableRoot\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":true,\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"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\":\"error\",\"name\":\"CertificateInvalid\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootInFuture\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidConfirmationThreshold\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCurveType\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidGlobalTableRoot\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidMessageHash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSetProof\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidProofLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidShortString\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignatureLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"StringTooLong\",\"inputs\":[{\"name\":\"str\",\"type\":\"string\",\"internalType\":\"string\"}]},{\"type\":\"error\",\"name\":\"TableUpdateForPastTimestamp\",\"inputs\":[]}]", + Bin: "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", } // OperatorTableUpdaterABI is the input ABI used to generate the binding from. diff --git a/pkg/bindings/OperatorTableUpdaterStorage/binding.go b/pkg/bindings/OperatorTableUpdaterStorage/binding.go index 139c4ab348..19458bfa58 100644 --- a/pkg/bindings/OperatorTableUpdaterStorage/binding.go +++ b/pkg/bindings/OperatorTableUpdaterStorage/binding.go @@ -71,7 +71,7 @@ type OperatorSet struct { // OperatorTableUpdaterStorageMetaData contains all meta data concerning the OperatorTableUpdaterStorage contract. var OperatorTableUpdaterStorageMetaData = &bind.MetaData{ - ABI: "[{\"type\":\"function\",\"name\":\"GLOBAL_TABLE_ROOT_CERT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"MAX_BPS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"bn254CertificateVerifier\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBN254CertificateVerifier\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"confirmGlobalTableRoot\",\"inputs\":[{\"name\":\"globalTableRootCert\",\"type\":\"tuple\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254Certificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"apk\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"nonSignerWitnesses\",\"type\":\"tuple[]\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254OperatorInfoWitness[]\",\"components\":[{\"name\":\"operatorIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfoProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorInfo\",\"components\":[{\"name\":\"pubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}]}]},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"ecdsaCertificateVerifier\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIECDSACertificateVerifier\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCertificateVerifier\",\"inputs\":[{\"name\":\"curveType\",\"type\":\"uint8\",\"internalType\":\"enumIKeyRegistrarTypes.CurveType\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentGlobalTableRoot\",\"inputs\":[],\"outputs\":[{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalConfirmerSetReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalRootConfirmerSet\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableRootByTimestamp\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"tableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableUpdateMessageHash\",\"inputs\":[{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getLatestReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"globalRootConfirmationThreshold\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmationThreshold\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmerSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"operatorSetIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorTableBytes\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"GlobalRootConfirmationThresholdUpdated\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"GlobalRootConfirmerSetUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewGlobalTableRoot\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":true,\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CertificateInvalid\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootInFuture\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidConfirmationThreshold\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCurveType\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidGlobalTableRoot\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidMessageHash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSetProof\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TableUpdateForPastTimestamp\",\"inputs\":[]}]", + ABI: "[{\"type\":\"function\",\"name\":\"GLOBAL_TABLE_ROOT_CERT_TYPEHASH\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"MAX_BPS\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"bn254CertificateVerifier\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIBN254CertificateVerifier\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"confirmGlobalTableRoot\",\"inputs\":[{\"name\":\"globalTableRootCert\",\"type\":\"tuple\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254Certificate\",\"components\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"messageHash\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"signature\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"apk\",\"type\":\"tuple\",\"internalType\":\"structBN254.G2Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"},{\"name\":\"Y\",\"type\":\"uint256[2]\",\"internalType\":\"uint256[2]\"}]},{\"name\":\"nonSignerWitnesses\",\"type\":\"tuple[]\",\"internalType\":\"structIBN254CertificateVerifierTypes.BN254OperatorInfoWitness[]\",\"components\":[{\"name\":\"operatorIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"operatorInfoProof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorInfo\",\"type\":\"tuple\",\"internalType\":\"structIBN254TableCalculatorTypes.BN254OperatorInfo\",\"components\":[{\"name\":\"pubkey\",\"type\":\"tuple\",\"internalType\":\"structBN254.G1Point\",\"components\":[{\"name\":\"X\",\"type\":\"uint256\",\"internalType\":\"uint256\"},{\"name\":\"Y\",\"type\":\"uint256\",\"internalType\":\"uint256\"}]},{\"name\":\"weights\",\"type\":\"uint256[]\",\"internalType\":\"uint256[]\"}]}]}]},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"ecdsaCertificateVerifier\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"contractIECDSACertificateVerifier\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCertificateVerifier\",\"inputs\":[{\"name\":\"curveType\",\"type\":\"uint8\",\"internalType\":\"enumIKeyRegistrarTypes.CurveType\"}],\"outputs\":[{\"name\":\"\",\"type\":\"address\",\"internalType\":\"address\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getCurrentGlobalTableRoot\",\"inputs\":[],\"outputs\":[{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalConfirmerSetReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalRootConfirmerSet\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableRootByTimestamp\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"tableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getGlobalTableUpdateMessageHash\",\"inputs\":[{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"outputs\":[{\"name\":\"\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"getLatestReferenceTimestamp\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint32\",\"internalType\":\"uint32\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"globalRootConfirmationThreshold\",\"inputs\":[],\"outputs\":[{\"name\":\"\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"stateMutability\":\"view\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmationThreshold\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"internalType\":\"uint16\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"setGlobalRootConfirmerSet\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"function\",\"name\":\"updateOperatorTable\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"internalType\":\"bytes32\"},{\"name\":\"operatorSetIndex\",\"type\":\"uint32\",\"internalType\":\"uint32\"},{\"name\":\"proof\",\"type\":\"bytes\",\"internalType\":\"bytes\"},{\"name\":\"operatorTableBytes\",\"type\":\"bytes\",\"internalType\":\"bytes\"}],\"outputs\":[],\"stateMutability\":\"nonpayable\"},{\"type\":\"event\",\"name\":\"GlobalRootConfirmationThresholdUpdated\",\"inputs\":[{\"name\":\"bps\",\"type\":\"uint16\",\"indexed\":false,\"internalType\":\"uint16\"}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"GlobalRootConfirmerSetUpdated\",\"inputs\":[{\"name\":\"operatorSet\",\"type\":\"tuple\",\"indexed\":false,\"internalType\":\"structOperatorSet\",\"components\":[{\"name\":\"avs\",\"type\":\"address\",\"internalType\":\"address\"},{\"name\":\"id\",\"type\":\"uint32\",\"internalType\":\"uint32\"}]}],\"anonymous\":false},{\"type\":\"event\",\"name\":\"NewGlobalTableRoot\",\"inputs\":[{\"name\":\"referenceTimestamp\",\"type\":\"uint32\",\"indexed\":true,\"internalType\":\"uint32\"},{\"name\":\"globalTableRoot\",\"type\":\"bytes32\",\"indexed\":true,\"internalType\":\"bytes32\"}],\"anonymous\":false},{\"type\":\"error\",\"name\":\"CertificateInvalid\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootInFuture\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"GlobalTableRootStale\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidConfirmationThreshold\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidCurveType\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidGlobalTableRoot\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidMessageHash\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidOperatorSetProof\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"InvalidSignatureLength\",\"inputs\":[]},{\"type\":\"error\",\"name\":\"TableUpdateForPastTimestamp\",\"inputs\":[]}]", } // OperatorTableUpdaterStorageABI is the input ABI used to generate the binding from.