eigenlayer_contract_deployer/bindings/core/
socket_registry.rs

1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use SocketRegistry::*;
3
4/**
5
6Generated by the following Solidity interface...
7```solidity
8interface SocketRegistry {
9    error OnlySlashingRegistryCoordinator();
10
11    constructor(address _slashingRegistryCoordinator);
12
13    function getOperatorSocket(bytes32 _operatorId) external view returns (string memory);
14    function operatorIdToSocket(bytes32) external view returns (string memory);
15    function setOperatorSocket(bytes32 _operatorId, string memory _socket) external;
16    function slashingRegistryCoordinator() external view returns (address);
17}
18```
19
20...which was generated by the following JSON ABI:
21```json
22[
23  {
24    "type": "constructor",
25    "inputs": [
26      {
27        "name": "_slashingRegistryCoordinator",
28        "type": "address",
29        "internalType": "contract ISlashingRegistryCoordinator"
30      }
31    ],
32    "stateMutability": "nonpayable"
33  },
34  {
35    "type": "function",
36    "name": "getOperatorSocket",
37    "inputs": [
38      {
39        "name": "_operatorId",
40        "type": "bytes32",
41        "internalType": "bytes32"
42      }
43    ],
44    "outputs": [
45      {
46        "name": "",
47        "type": "string",
48        "internalType": "string"
49      }
50    ],
51    "stateMutability": "view"
52  },
53  {
54    "type": "function",
55    "name": "operatorIdToSocket",
56    "inputs": [
57      {
58        "name": "",
59        "type": "bytes32",
60        "internalType": "bytes32"
61      }
62    ],
63    "outputs": [
64      {
65        "name": "",
66        "type": "string",
67        "internalType": "string"
68      }
69    ],
70    "stateMutability": "view"
71  },
72  {
73    "type": "function",
74    "name": "setOperatorSocket",
75    "inputs": [
76      {
77        "name": "_operatorId",
78        "type": "bytes32",
79        "internalType": "bytes32"
80      },
81      {
82        "name": "_socket",
83        "type": "string",
84        "internalType": "string"
85      }
86    ],
87    "outputs": [],
88    "stateMutability": "nonpayable"
89  },
90  {
91    "type": "function",
92    "name": "slashingRegistryCoordinator",
93    "inputs": [],
94    "outputs": [
95      {
96        "name": "",
97        "type": "address",
98        "internalType": "address"
99      }
100    ],
101    "stateMutability": "view"
102  },
103  {
104    "type": "error",
105    "name": "OnlySlashingRegistryCoordinator",
106    "inputs": []
107  }
108]
109```*/
110#[allow(
111    non_camel_case_types,
112    non_snake_case,
113    clippy::pub_underscore_fields,
114    clippy::style,
115    clippy::empty_structs_with_brackets
116)]
117pub mod SocketRegistry {
118    use super::*;
119    use alloy::sol_types as alloy_sol_types;
120    /// The creation / init bytecode of the contract.
121    ///
122    /// ```text
123    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
124    /// ```
125    #[rustfmt::skip]
126    #[allow(clippy::all)]
127    pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
128        b"`\xA0`@R4\x80\x15`\x0EW__\xFD[P`@Qa\x05\xA48\x03\x80a\x05\xA4\x839\x81\x01`@\x81\x90R`+\x91`;V[`\x01`\x01`\xA0\x1B\x03\x16`\x80R`fV[_` \x82\x84\x03\x12\x15`JW__\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14`_W__\xFD[\x93\x92PPPV[`\x80Qa\x05 a\0\x84_9_\x81\x81`\x8F\x01Ra\x02\x1F\x01Ra\x05 _\xF3\xFE`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x10\xBE\xA0\xD7\x14a\0NW\x80c\xAFe\xFD\xFC\x14a\0wW\x80c\xCF\x1DkB\x14a\0\x8AW\x80c\xF0C6~\x14a\0\xC9W[__\xFD[a\0aa\0\\6`\x04a\x02yV[a\0\xDEV[`@Qa\0n\x91\x90a\x02\x90V[`@Q\x80\x91\x03\x90\xF3[a\0aa\0\x856`\x04a\x02yV[a\x01}V[a\0\xB1\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0nV[a\0\xDCa\0\xD76`\x04a\x02\xEFV[a\x02\x14V[\0[_\x81\x81R` \x81\x90R`@\x90 \x80T``\x91\x90a\0\xFA\x90a\x03\xACV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x01&\x90a\x03\xACV[\x80\x15a\x01qW\x80`\x1F\x10a\x01HWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x01qV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x01TW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x91\x90PV[_` \x81\x90R\x90\x81R`@\x90 \x80Ta\x01\x95\x90a\x03\xACV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x01\xC1\x90a\x03\xACV[\x80\x15a\x02\x0CW\x80`\x1F\x10a\x01\xE3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\x0CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x01\xEFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81V[3`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x02]W`@Qc,\x01\xB2\x05`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x82\x81R` \x81\x90R`@\x90 a\x02t\x82\x82a\x04/V[PPPV[_` \x82\x84\x03\x12\x15a\x02\x89W__\xFD[P5\x91\x90PV[` \x81R_\x82Q\x80` \x84\x01R_[\x81\x81\x10\x15a\x02\xBCW` \x81\x86\x01\x81\x01Q`@\x86\x84\x01\x01R\x01a\x02\x9FV[P_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[__`@\x83\x85\x03\x12\x15a\x03\0W__\xFD[\x825\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\x1DW__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a\x03-W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03GWa\x03Ga\x02\xDBV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x03vWa\x03va\x02\xDBV[`@R\x81\x81R\x82\x82\x01` \x01\x87\x10\x15a\x03\x8DW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x03\xC0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x03\xDEWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x02tW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x04\tWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x04(W_\x81U`\x01\x01a\x04\x15V[PPPPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04IWa\x04Ia\x02\xDBV[a\x04]\x81a\x04W\x84Ta\x03\xACV[\x84a\x03\xE4V[` `\x1F\x82\x11`\x01\x81\x14a\x04\x8FW_\x83\x15a\x04xWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x04(V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x04\xBEW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x04\x9EV[P\x84\x82\x10\x15a\x04\xDBW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV\xFE\xA2dipfsX\"\x12 \x0F\xC2p\x10\x0C\xE6hP\xFA\xBB_\xCAi\xA3\xF7\xD5\x1C\x06Z\x16@\x96\xBA;\xD0\xC4\xF5\xC1\x1DE_qdsolcC\0\x08\x1B\x003",
129    );
130    /// The runtime bytecode of the contract, as deployed on the network.
131    ///
132    /// ```text
133    ///0x608060405234801561000f575f5ffd5b506004361061004a575f3560e01c806310bea0d71461004e578063af65fdfc14610077578063cf1d6b421461008a578063f043367e146100c9575b5f5ffd5b61006161005c366004610279565b6100de565b60405161006e9190610290565b60405180910390f35b610061610085366004610279565b61017d565b6100b17f000000000000000000000000000000000000000000000000000000000000000081565b6040516001600160a01b03909116815260200161006e565b6100dc6100d73660046102ef565b610214565b005b5f8181526020819052604090208054606091906100fa906103ac565b80601f0160208091040260200160405190810160405280929190818152602001828054610126906103ac565b80156101715780601f1061014857610100808354040283529160200191610171565b820191905f5260205f20905b81548152906001019060200180831161015457829003601f168201915b50505050509050919050565b5f6020819052908152604090208054610195906103ac565b80601f01602080910402602001604051908101604052809291908181526020018280546101c1906103ac565b801561020c5780601f106101e35761010080835404028352916020019161020c565b820191905f5260205f20905b8154815290600101906020018083116101ef57829003601f168201915b505050505081565b336001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000161461025d57604051632c01b20560e21b815260040160405180910390fd5b5f828152602081905260409020610274828261042f565b505050565b5f60208284031215610289575f5ffd5b5035919050565b602081525f82518060208401525f5b818110156102bc576020818601810151604086840101520161029f565b505f604082850101526040601f19601f83011684010191505092915050565b634e487b7160e01b5f52604160045260245ffd5b5f5f60408385031215610300575f5ffd5b82359150602083013567ffffffffffffffff81111561031d575f5ffd5b8301601f8101851361032d575f5ffd5b803567ffffffffffffffff811115610347576103476102db565b604051601f8201601f19908116603f0116810167ffffffffffffffff81118282101715610376576103766102db565b60405281815282820160200187101561038d575f5ffd5b816020840160208301375f602083830101528093505050509250929050565b600181811c908216806103c057607f821691505b6020821081036103de57634e487b7160e01b5f52602260045260245ffd5b50919050565b601f82111561027457805f5260205f20601f840160051c810160208510156104095750805b601f840160051c820191505b81811015610428575f8155600101610415565b5050505050565b815167ffffffffffffffff811115610449576104496102db565b61045d8161045784546103ac565b846103e4565b6020601f82116001811461048f575f83156104785750848201515b5f19600385901b1c1916600184901b178455610428565b5f84815260208120601f198516915b828110156104be578785015182556020948501946001909201910161049e565b50848210156104db57868401515f19600387901b60f8161c191681555b50505050600190811b0190555056fea26469706673582212200fc270100ce66850fabb5fca69a3f7d51c065a164096ba3bd0c4f5c11d455f7164736f6c634300081b0033
134    /// ```
135    #[rustfmt::skip]
136    #[allow(clippy::all)]
137    pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
138        b"`\x80`@R4\x80\x15a\0\x0FW__\xFD[P`\x046\x10a\0JW_5`\xE0\x1C\x80c\x10\xBE\xA0\xD7\x14a\0NW\x80c\xAFe\xFD\xFC\x14a\0wW\x80c\xCF\x1DkB\x14a\0\x8AW\x80c\xF0C6~\x14a\0\xC9W[__\xFD[a\0aa\0\\6`\x04a\x02yV[a\0\xDEV[`@Qa\0n\x91\x90a\x02\x90V[`@Q\x80\x91\x03\x90\xF3[a\0aa\0\x856`\x04a\x02yV[a\x01}V[a\0\xB1\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x81V[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0nV[a\0\xDCa\0\xD76`\x04a\x02\xEFV[a\x02\x14V[\0[_\x81\x81R` \x81\x90R`@\x90 \x80T``\x91\x90a\0\xFA\x90a\x03\xACV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x01&\x90a\x03\xACV[\x80\x15a\x01qW\x80`\x1F\x10a\x01HWa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x01qV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x01TW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x90P\x91\x90PV[_` \x81\x90R\x90\x81R`@\x90 \x80Ta\x01\x95\x90a\x03\xACV[\x80`\x1F\x01` \x80\x91\x04\x02` \x01`@Q\x90\x81\x01`@R\x80\x92\x91\x90\x81\x81R` \x01\x82\x80Ta\x01\xC1\x90a\x03\xACV[\x80\x15a\x02\x0CW\x80`\x1F\x10a\x01\xE3Wa\x01\0\x80\x83T\x04\x02\x83R\x91` \x01\x91a\x02\x0CV[\x82\x01\x91\x90_R` _ \x90[\x81T\x81R\x90`\x01\x01\x90` \x01\x80\x83\x11a\x01\xEFW\x82\x90\x03`\x1F\x16\x82\x01\x91[PPPPP\x81V[3`\x01`\x01`\xA0\x1B\x03\x7F\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x16\x14a\x02]W`@Qc,\x01\xB2\x05`\xE2\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[_\x82\x81R` \x81\x90R`@\x90 a\x02t\x82\x82a\x04/V[PPPV[_` \x82\x84\x03\x12\x15a\x02\x89W__\xFD[P5\x91\x90PV[` \x81R_\x82Q\x80` \x84\x01R_[\x81\x81\x10\x15a\x02\xBCW` \x81\x86\x01\x81\x01Q`@\x86\x84\x01\x01R\x01a\x02\x9FV[P_`@\x82\x85\x01\x01R`@`\x1F\x19`\x1F\x83\x01\x16\x84\x01\x01\x91PP\x92\x91PPV[cNH{q`\xE0\x1B_R`A`\x04R`$_\xFD[__`@\x83\x85\x03\x12\x15a\x03\0W__\xFD[\x825\x91P` \x83\x015g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03\x1DW__\xFD[\x83\x01`\x1F\x81\x01\x85\x13a\x03-W__\xFD[\x805g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x03GWa\x03Ga\x02\xDBV[`@Q`\x1F\x82\x01`\x1F\x19\x90\x81\x16`?\x01\x16\x81\x01g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x82\x82\x10\x17\x15a\x03vWa\x03va\x02\xDBV[`@R\x81\x81R\x82\x82\x01` \x01\x87\x10\x15a\x03\x8DW__\xFD[\x81` \x84\x01` \x83\x017_` \x83\x83\x01\x01R\x80\x93PPPP\x92P\x92\x90PV[`\x01\x81\x81\x1C\x90\x82\x16\x80a\x03\xC0W`\x7F\x82\x16\x91P[` \x82\x10\x81\x03a\x03\xDEWcNH{q`\xE0\x1B_R`\"`\x04R`$_\xFD[P\x91\x90PV[`\x1F\x82\x11\x15a\x02tW\x80_R` _ `\x1F\x84\x01`\x05\x1C\x81\x01` \x85\x10\x15a\x04\tWP\x80[`\x1F\x84\x01`\x05\x1C\x82\x01\x91P[\x81\x81\x10\x15a\x04(W_\x81U`\x01\x01a\x04\x15V[PPPPPV[\x81Qg\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x11\x15a\x04IWa\x04Ia\x02\xDBV[a\x04]\x81a\x04W\x84Ta\x03\xACV[\x84a\x03\xE4V[` `\x1F\x82\x11`\x01\x81\x14a\x04\x8FW_\x83\x15a\x04xWP\x84\x82\x01Q[_\x19`\x03\x85\x90\x1B\x1C\x19\x16`\x01\x84\x90\x1B\x17\x84Ua\x04(V[_\x84\x81R` \x81 `\x1F\x19\x85\x16\x91[\x82\x81\x10\x15a\x04\xBEW\x87\x85\x01Q\x82U` \x94\x85\x01\x94`\x01\x90\x92\x01\x91\x01a\x04\x9EV[P\x84\x82\x10\x15a\x04\xDBW\x86\x84\x01Q_\x19`\x03\x87\x90\x1B`\xF8\x16\x1C\x19\x16\x81U[PPPP`\x01\x90\x81\x1B\x01\x90UPV\xFE\xA2dipfsX\"\x12 \x0F\xC2p\x10\x0C\xE6hP\xFA\xBB_\xCAi\xA3\xF7\xD5\x1C\x06Z\x16@\x96\xBA;\xD0\xC4\xF5\xC1\x1DE_qdsolcC\0\x08\x1B\x003",
139    );
140    #[derive(serde::Serialize, serde::Deserialize)]
141    #[derive(Default, Debug, PartialEq, Eq, Hash)]
142    /**Custom error with signature `OnlySlashingRegistryCoordinator()` and selector `0xb006c814`.
143```solidity
144error OnlySlashingRegistryCoordinator();
145```*/
146    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
147    #[derive(Clone)]
148    pub struct OnlySlashingRegistryCoordinator;
149    #[allow(
150        non_camel_case_types,
151        non_snake_case,
152        clippy::pub_underscore_fields,
153        clippy::style
154    )]
155    const _: () = {
156        use alloy::sol_types as alloy_sol_types;
157        #[doc(hidden)]
158        type UnderlyingSolTuple<'a> = ();
159        #[doc(hidden)]
160        type UnderlyingRustTuple<'a> = ();
161        #[cfg(test)]
162        #[allow(dead_code, unreachable_patterns)]
163        fn _type_assertion(
164            _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
165        ) {
166            match _t {
167                alloy_sol_types::private::AssertTypeEq::<
168                    <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
169                >(_) => {}
170            }
171        }
172        #[automatically_derived]
173        #[doc(hidden)]
174        impl ::core::convert::From<OnlySlashingRegistryCoordinator>
175        for UnderlyingRustTuple<'_> {
176            fn from(value: OnlySlashingRegistryCoordinator) -> Self {
177                ()
178            }
179        }
180        #[automatically_derived]
181        #[doc(hidden)]
182        impl ::core::convert::From<UnderlyingRustTuple<'_>>
183        for OnlySlashingRegistryCoordinator {
184            fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
185                Self
186            }
187        }
188        #[automatically_derived]
189        impl alloy_sol_types::SolError for OnlySlashingRegistryCoordinator {
190            type Parameters<'a> = UnderlyingSolTuple<'a>;
191            type Token<'a> = <Self::Parameters<
192                'a,
193            > as alloy_sol_types::SolType>::Token<'a>;
194            const SIGNATURE: &'static str = "OnlySlashingRegistryCoordinator()";
195            const SELECTOR: [u8; 4] = [176u8, 6u8, 200u8, 20u8];
196            #[inline]
197            fn new<'a>(
198                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
199            ) -> Self {
200                tuple.into()
201            }
202            #[inline]
203            fn tokenize(&self) -> Self::Token<'_> {
204                ()
205            }
206            #[inline]
207            fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
208                <Self::Parameters<
209                    '_,
210                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
211                    .map(Self::new)
212            }
213        }
214    };
215    /**Constructor`.
216```solidity
217constructor(address _slashingRegistryCoordinator);
218```*/
219    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
220    #[derive(Clone)]
221    pub struct constructorCall {
222        #[allow(missing_docs)]
223        pub _slashingRegistryCoordinator: alloy::sol_types::private::Address,
224    }
225    const _: () = {
226        use alloy::sol_types as alloy_sol_types;
227        {
228            #[doc(hidden)]
229            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
230            #[doc(hidden)]
231            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
232            #[cfg(test)]
233            #[allow(dead_code, unreachable_patterns)]
234            fn _type_assertion(
235                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
236            ) {
237                match _t {
238                    alloy_sol_types::private::AssertTypeEq::<
239                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
240                    >(_) => {}
241                }
242            }
243            #[automatically_derived]
244            #[doc(hidden)]
245            impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
246                fn from(value: constructorCall) -> Self {
247                    (value._slashingRegistryCoordinator,)
248                }
249            }
250            #[automatically_derived]
251            #[doc(hidden)]
252            impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
253                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
254                    Self {
255                        _slashingRegistryCoordinator: tuple.0,
256                    }
257                }
258            }
259        }
260        #[automatically_derived]
261        impl alloy_sol_types::SolConstructor for constructorCall {
262            type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
263            type Token<'a> = <Self::Parameters<
264                'a,
265            > as alloy_sol_types::SolType>::Token<'a>;
266            #[inline]
267            fn new<'a>(
268                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
269            ) -> Self {
270                tuple.into()
271            }
272            #[inline]
273            fn tokenize(&self) -> Self::Token<'_> {
274                (
275                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
276                        &self._slashingRegistryCoordinator,
277                    ),
278                )
279            }
280        }
281    };
282    #[derive(serde::Serialize, serde::Deserialize)]
283    #[derive(Default, Debug, PartialEq, Eq, Hash)]
284    /**Function with signature `getOperatorSocket(bytes32)` and selector `0x10bea0d7`.
285```solidity
286function getOperatorSocket(bytes32 _operatorId) external view returns (string memory);
287```*/
288    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
289    #[derive(Clone)]
290    pub struct getOperatorSocketCall {
291        #[allow(missing_docs)]
292        pub _operatorId: alloy::sol_types::private::FixedBytes<32>,
293    }
294    #[derive(serde::Serialize, serde::Deserialize)]
295    #[derive(Default, Debug, PartialEq, Eq, Hash)]
296    ///Container type for the return parameters of the [`getOperatorSocket(bytes32)`](getOperatorSocketCall) function.
297    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
298    #[derive(Clone)]
299    pub struct getOperatorSocketReturn {
300        #[allow(missing_docs)]
301        pub _0: alloy::sol_types::private::String,
302    }
303    #[allow(
304        non_camel_case_types,
305        non_snake_case,
306        clippy::pub_underscore_fields,
307        clippy::style
308    )]
309    const _: () = {
310        use alloy::sol_types as alloy_sol_types;
311        {
312            #[doc(hidden)]
313            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
314            #[doc(hidden)]
315            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
316            #[cfg(test)]
317            #[allow(dead_code, unreachable_patterns)]
318            fn _type_assertion(
319                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
320            ) {
321                match _t {
322                    alloy_sol_types::private::AssertTypeEq::<
323                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
324                    >(_) => {}
325                }
326            }
327            #[automatically_derived]
328            #[doc(hidden)]
329            impl ::core::convert::From<getOperatorSocketCall>
330            for UnderlyingRustTuple<'_> {
331                fn from(value: getOperatorSocketCall) -> Self {
332                    (value._operatorId,)
333                }
334            }
335            #[automatically_derived]
336            #[doc(hidden)]
337            impl ::core::convert::From<UnderlyingRustTuple<'_>>
338            for getOperatorSocketCall {
339                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
340                    Self { _operatorId: tuple.0 }
341                }
342            }
343        }
344        {
345            #[doc(hidden)]
346            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
347            #[doc(hidden)]
348            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
349            #[cfg(test)]
350            #[allow(dead_code, unreachable_patterns)]
351            fn _type_assertion(
352                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
353            ) {
354                match _t {
355                    alloy_sol_types::private::AssertTypeEq::<
356                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
357                    >(_) => {}
358                }
359            }
360            #[automatically_derived]
361            #[doc(hidden)]
362            impl ::core::convert::From<getOperatorSocketReturn>
363            for UnderlyingRustTuple<'_> {
364                fn from(value: getOperatorSocketReturn) -> Self {
365                    (value._0,)
366                }
367            }
368            #[automatically_derived]
369            #[doc(hidden)]
370            impl ::core::convert::From<UnderlyingRustTuple<'_>>
371            for getOperatorSocketReturn {
372                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
373                    Self { _0: tuple.0 }
374                }
375            }
376        }
377        #[automatically_derived]
378        impl alloy_sol_types::SolCall for getOperatorSocketCall {
379            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
380            type Token<'a> = <Self::Parameters<
381                'a,
382            > as alloy_sol_types::SolType>::Token<'a>;
383            type Return = alloy::sol_types::private::String;
384            type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
385            type ReturnToken<'a> = <Self::ReturnTuple<
386                'a,
387            > as alloy_sol_types::SolType>::Token<'a>;
388            const SIGNATURE: &'static str = "getOperatorSocket(bytes32)";
389            const SELECTOR: [u8; 4] = [16u8, 190u8, 160u8, 215u8];
390            #[inline]
391            fn new<'a>(
392                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
393            ) -> Self {
394                tuple.into()
395            }
396            #[inline]
397            fn tokenize(&self) -> Self::Token<'_> {
398                (
399                    <alloy::sol_types::sol_data::FixedBytes<
400                        32,
401                    > as alloy_sol_types::SolType>::tokenize(&self._operatorId),
402                )
403            }
404            #[inline]
405            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
406                (
407                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
408                        ret,
409                    ),
410                )
411            }
412            #[inline]
413            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
414                <Self::ReturnTuple<
415                    '_,
416                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
417                    .map(|r| {
418                        let r: getOperatorSocketReturn = r.into();
419                        r._0
420                    })
421            }
422            #[inline]
423            fn abi_decode_returns_validate(
424                data: &[u8],
425            ) -> alloy_sol_types::Result<Self::Return> {
426                <Self::ReturnTuple<
427                    '_,
428                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
429                    .map(|r| {
430                        let r: getOperatorSocketReturn = r.into();
431                        r._0
432                    })
433            }
434        }
435    };
436    #[derive(serde::Serialize, serde::Deserialize)]
437    #[derive(Default, Debug, PartialEq, Eq, Hash)]
438    /**Function with signature `operatorIdToSocket(bytes32)` and selector `0xaf65fdfc`.
439```solidity
440function operatorIdToSocket(bytes32) external view returns (string memory);
441```*/
442    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
443    #[derive(Clone)]
444    pub struct operatorIdToSocketCall(pub alloy::sol_types::private::FixedBytes<32>);
445    #[derive(serde::Serialize, serde::Deserialize)]
446    #[derive(Default, Debug, PartialEq, Eq, Hash)]
447    ///Container type for the return parameters of the [`operatorIdToSocket(bytes32)`](operatorIdToSocketCall) function.
448    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
449    #[derive(Clone)]
450    pub struct operatorIdToSocketReturn {
451        #[allow(missing_docs)]
452        pub _0: alloy::sol_types::private::String,
453    }
454    #[allow(
455        non_camel_case_types,
456        non_snake_case,
457        clippy::pub_underscore_fields,
458        clippy::style
459    )]
460    const _: () = {
461        use alloy::sol_types as alloy_sol_types;
462        {
463            #[doc(hidden)]
464            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
465            #[doc(hidden)]
466            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
467            #[cfg(test)]
468            #[allow(dead_code, unreachable_patterns)]
469            fn _type_assertion(
470                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
471            ) {
472                match _t {
473                    alloy_sol_types::private::AssertTypeEq::<
474                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
475                    >(_) => {}
476                }
477            }
478            #[automatically_derived]
479            #[doc(hidden)]
480            impl ::core::convert::From<operatorIdToSocketCall>
481            for UnderlyingRustTuple<'_> {
482                fn from(value: operatorIdToSocketCall) -> Self {
483                    (value.0,)
484                }
485            }
486            #[automatically_derived]
487            #[doc(hidden)]
488            impl ::core::convert::From<UnderlyingRustTuple<'_>>
489            for operatorIdToSocketCall {
490                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
491                    Self(tuple.0)
492                }
493            }
494        }
495        {
496            #[doc(hidden)]
497            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
498            #[doc(hidden)]
499            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
500            #[cfg(test)]
501            #[allow(dead_code, unreachable_patterns)]
502            fn _type_assertion(
503                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
504            ) {
505                match _t {
506                    alloy_sol_types::private::AssertTypeEq::<
507                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
508                    >(_) => {}
509                }
510            }
511            #[automatically_derived]
512            #[doc(hidden)]
513            impl ::core::convert::From<operatorIdToSocketReturn>
514            for UnderlyingRustTuple<'_> {
515                fn from(value: operatorIdToSocketReturn) -> Self {
516                    (value._0,)
517                }
518            }
519            #[automatically_derived]
520            #[doc(hidden)]
521            impl ::core::convert::From<UnderlyingRustTuple<'_>>
522            for operatorIdToSocketReturn {
523                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
524                    Self { _0: tuple.0 }
525                }
526            }
527        }
528        #[automatically_derived]
529        impl alloy_sol_types::SolCall for operatorIdToSocketCall {
530            type Parameters<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
531            type Token<'a> = <Self::Parameters<
532                'a,
533            > as alloy_sol_types::SolType>::Token<'a>;
534            type Return = alloy::sol_types::private::String;
535            type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
536            type ReturnToken<'a> = <Self::ReturnTuple<
537                'a,
538            > as alloy_sol_types::SolType>::Token<'a>;
539            const SIGNATURE: &'static str = "operatorIdToSocket(bytes32)";
540            const SELECTOR: [u8; 4] = [175u8, 101u8, 253u8, 252u8];
541            #[inline]
542            fn new<'a>(
543                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
544            ) -> Self {
545                tuple.into()
546            }
547            #[inline]
548            fn tokenize(&self) -> Self::Token<'_> {
549                (
550                    <alloy::sol_types::sol_data::FixedBytes<
551                        32,
552                    > as alloy_sol_types::SolType>::tokenize(&self.0),
553                )
554            }
555            #[inline]
556            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
557                (
558                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
559                        ret,
560                    ),
561                )
562            }
563            #[inline]
564            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
565                <Self::ReturnTuple<
566                    '_,
567                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
568                    .map(|r| {
569                        let r: operatorIdToSocketReturn = r.into();
570                        r._0
571                    })
572            }
573            #[inline]
574            fn abi_decode_returns_validate(
575                data: &[u8],
576            ) -> alloy_sol_types::Result<Self::Return> {
577                <Self::ReturnTuple<
578                    '_,
579                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
580                    .map(|r| {
581                        let r: operatorIdToSocketReturn = r.into();
582                        r._0
583                    })
584            }
585        }
586    };
587    #[derive(serde::Serialize, serde::Deserialize)]
588    #[derive(Default, Debug, PartialEq, Eq, Hash)]
589    /**Function with signature `setOperatorSocket(bytes32,string)` and selector `0xf043367e`.
590```solidity
591function setOperatorSocket(bytes32 _operatorId, string memory _socket) external;
592```*/
593    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
594    #[derive(Clone)]
595    pub struct setOperatorSocketCall {
596        #[allow(missing_docs)]
597        pub _operatorId: alloy::sol_types::private::FixedBytes<32>,
598        #[allow(missing_docs)]
599        pub _socket: alloy::sol_types::private::String,
600    }
601    ///Container type for the return parameters of the [`setOperatorSocket(bytes32,string)`](setOperatorSocketCall) function.
602    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
603    #[derive(Clone)]
604    pub struct setOperatorSocketReturn {}
605    #[allow(
606        non_camel_case_types,
607        non_snake_case,
608        clippy::pub_underscore_fields,
609        clippy::style
610    )]
611    const _: () = {
612        use alloy::sol_types as alloy_sol_types;
613        {
614            #[doc(hidden)]
615            type UnderlyingSolTuple<'a> = (
616                alloy::sol_types::sol_data::FixedBytes<32>,
617                alloy::sol_types::sol_data::String,
618            );
619            #[doc(hidden)]
620            type UnderlyingRustTuple<'a> = (
621                alloy::sol_types::private::FixedBytes<32>,
622                alloy::sol_types::private::String,
623            );
624            #[cfg(test)]
625            #[allow(dead_code, unreachable_patterns)]
626            fn _type_assertion(
627                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
628            ) {
629                match _t {
630                    alloy_sol_types::private::AssertTypeEq::<
631                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
632                    >(_) => {}
633                }
634            }
635            #[automatically_derived]
636            #[doc(hidden)]
637            impl ::core::convert::From<setOperatorSocketCall>
638            for UnderlyingRustTuple<'_> {
639                fn from(value: setOperatorSocketCall) -> Self {
640                    (value._operatorId, value._socket)
641                }
642            }
643            #[automatically_derived]
644            #[doc(hidden)]
645            impl ::core::convert::From<UnderlyingRustTuple<'_>>
646            for setOperatorSocketCall {
647                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
648                    Self {
649                        _operatorId: tuple.0,
650                        _socket: tuple.1,
651                    }
652                }
653            }
654        }
655        {
656            #[doc(hidden)]
657            type UnderlyingSolTuple<'a> = ();
658            #[doc(hidden)]
659            type UnderlyingRustTuple<'a> = ();
660            #[cfg(test)]
661            #[allow(dead_code, unreachable_patterns)]
662            fn _type_assertion(
663                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
664            ) {
665                match _t {
666                    alloy_sol_types::private::AssertTypeEq::<
667                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
668                    >(_) => {}
669                }
670            }
671            #[automatically_derived]
672            #[doc(hidden)]
673            impl ::core::convert::From<setOperatorSocketReturn>
674            for UnderlyingRustTuple<'_> {
675                fn from(value: setOperatorSocketReturn) -> Self {
676                    ()
677                }
678            }
679            #[automatically_derived]
680            #[doc(hidden)]
681            impl ::core::convert::From<UnderlyingRustTuple<'_>>
682            for setOperatorSocketReturn {
683                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
684                    Self {}
685                }
686            }
687        }
688        impl setOperatorSocketReturn {
689            fn _tokenize(
690                &self,
691            ) -> <setOperatorSocketCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
692                ()
693            }
694        }
695        #[automatically_derived]
696        impl alloy_sol_types::SolCall for setOperatorSocketCall {
697            type Parameters<'a> = (
698                alloy::sol_types::sol_data::FixedBytes<32>,
699                alloy::sol_types::sol_data::String,
700            );
701            type Token<'a> = <Self::Parameters<
702                'a,
703            > as alloy_sol_types::SolType>::Token<'a>;
704            type Return = setOperatorSocketReturn;
705            type ReturnTuple<'a> = ();
706            type ReturnToken<'a> = <Self::ReturnTuple<
707                'a,
708            > as alloy_sol_types::SolType>::Token<'a>;
709            const SIGNATURE: &'static str = "setOperatorSocket(bytes32,string)";
710            const SELECTOR: [u8; 4] = [240u8, 67u8, 54u8, 126u8];
711            #[inline]
712            fn new<'a>(
713                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
714            ) -> Self {
715                tuple.into()
716            }
717            #[inline]
718            fn tokenize(&self) -> Self::Token<'_> {
719                (
720                    <alloy::sol_types::sol_data::FixedBytes<
721                        32,
722                    > as alloy_sol_types::SolType>::tokenize(&self._operatorId),
723                    <alloy::sol_types::sol_data::String as alloy_sol_types::SolType>::tokenize(
724                        &self._socket,
725                    ),
726                )
727            }
728            #[inline]
729            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
730                setOperatorSocketReturn::_tokenize(ret)
731            }
732            #[inline]
733            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
734                <Self::ReturnTuple<
735                    '_,
736                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
737                    .map(Into::into)
738            }
739            #[inline]
740            fn abi_decode_returns_validate(
741                data: &[u8],
742            ) -> alloy_sol_types::Result<Self::Return> {
743                <Self::ReturnTuple<
744                    '_,
745                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
746                    .map(Into::into)
747            }
748        }
749    };
750    #[derive(serde::Serialize, serde::Deserialize)]
751    #[derive(Default, Debug, PartialEq, Eq, Hash)]
752    /**Function with signature `slashingRegistryCoordinator()` and selector `0xcf1d6b42`.
753```solidity
754function slashingRegistryCoordinator() external view returns (address);
755```*/
756    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
757    #[derive(Clone)]
758    pub struct slashingRegistryCoordinatorCall;
759    #[derive(serde::Serialize, serde::Deserialize)]
760    #[derive(Default, Debug, PartialEq, Eq, Hash)]
761    ///Container type for the return parameters of the [`slashingRegistryCoordinator()`](slashingRegistryCoordinatorCall) function.
762    #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
763    #[derive(Clone)]
764    pub struct slashingRegistryCoordinatorReturn {
765        #[allow(missing_docs)]
766        pub _0: alloy::sol_types::private::Address,
767    }
768    #[allow(
769        non_camel_case_types,
770        non_snake_case,
771        clippy::pub_underscore_fields,
772        clippy::style
773    )]
774    const _: () = {
775        use alloy::sol_types as alloy_sol_types;
776        {
777            #[doc(hidden)]
778            type UnderlyingSolTuple<'a> = ();
779            #[doc(hidden)]
780            type UnderlyingRustTuple<'a> = ();
781            #[cfg(test)]
782            #[allow(dead_code, unreachable_patterns)]
783            fn _type_assertion(
784                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
785            ) {
786                match _t {
787                    alloy_sol_types::private::AssertTypeEq::<
788                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
789                    >(_) => {}
790                }
791            }
792            #[automatically_derived]
793            #[doc(hidden)]
794            impl ::core::convert::From<slashingRegistryCoordinatorCall>
795            for UnderlyingRustTuple<'_> {
796                fn from(value: slashingRegistryCoordinatorCall) -> Self {
797                    ()
798                }
799            }
800            #[automatically_derived]
801            #[doc(hidden)]
802            impl ::core::convert::From<UnderlyingRustTuple<'_>>
803            for slashingRegistryCoordinatorCall {
804                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
805                    Self
806                }
807            }
808        }
809        {
810            #[doc(hidden)]
811            type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
812            #[doc(hidden)]
813            type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
814            #[cfg(test)]
815            #[allow(dead_code, unreachable_patterns)]
816            fn _type_assertion(
817                _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
818            ) {
819                match _t {
820                    alloy_sol_types::private::AssertTypeEq::<
821                        <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
822                    >(_) => {}
823                }
824            }
825            #[automatically_derived]
826            #[doc(hidden)]
827            impl ::core::convert::From<slashingRegistryCoordinatorReturn>
828            for UnderlyingRustTuple<'_> {
829                fn from(value: slashingRegistryCoordinatorReturn) -> Self {
830                    (value._0,)
831                }
832            }
833            #[automatically_derived]
834            #[doc(hidden)]
835            impl ::core::convert::From<UnderlyingRustTuple<'_>>
836            for slashingRegistryCoordinatorReturn {
837                fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
838                    Self { _0: tuple.0 }
839                }
840            }
841        }
842        #[automatically_derived]
843        impl alloy_sol_types::SolCall for slashingRegistryCoordinatorCall {
844            type Parameters<'a> = ();
845            type Token<'a> = <Self::Parameters<
846                'a,
847            > as alloy_sol_types::SolType>::Token<'a>;
848            type Return = alloy::sol_types::private::Address;
849            type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
850            type ReturnToken<'a> = <Self::ReturnTuple<
851                'a,
852            > as alloy_sol_types::SolType>::Token<'a>;
853            const SIGNATURE: &'static str = "slashingRegistryCoordinator()";
854            const SELECTOR: [u8; 4] = [207u8, 29u8, 107u8, 66u8];
855            #[inline]
856            fn new<'a>(
857                tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
858            ) -> Self {
859                tuple.into()
860            }
861            #[inline]
862            fn tokenize(&self) -> Self::Token<'_> {
863                ()
864            }
865            #[inline]
866            fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
867                (
868                    <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
869                        ret,
870                    ),
871                )
872            }
873            #[inline]
874            fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
875                <Self::ReturnTuple<
876                    '_,
877                > as alloy_sol_types::SolType>::abi_decode_sequence(data)
878                    .map(|r| {
879                        let r: slashingRegistryCoordinatorReturn = r.into();
880                        r._0
881                    })
882            }
883            #[inline]
884            fn abi_decode_returns_validate(
885                data: &[u8],
886            ) -> alloy_sol_types::Result<Self::Return> {
887                <Self::ReturnTuple<
888                    '_,
889                > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
890                    .map(|r| {
891                        let r: slashingRegistryCoordinatorReturn = r.into();
892                        r._0
893                    })
894            }
895        }
896    };
897    ///Container for all the [`SocketRegistry`](self) function calls.
898    #[derive(serde::Serialize, serde::Deserialize)]
899    #[derive()]
900    pub enum SocketRegistryCalls {
901        #[allow(missing_docs)]
902        getOperatorSocket(getOperatorSocketCall),
903        #[allow(missing_docs)]
904        operatorIdToSocket(operatorIdToSocketCall),
905        #[allow(missing_docs)]
906        setOperatorSocket(setOperatorSocketCall),
907        #[allow(missing_docs)]
908        slashingRegistryCoordinator(slashingRegistryCoordinatorCall),
909    }
910    #[automatically_derived]
911    impl SocketRegistryCalls {
912        /// All the selectors of this enum.
913        ///
914        /// Note that the selectors might not be in the same order as the variants.
915        /// No guarantees are made about the order of the selectors.
916        ///
917        /// Prefer using `SolInterface` methods instead.
918        pub const SELECTORS: &'static [[u8; 4usize]] = &[
919            [16u8, 190u8, 160u8, 215u8],
920            [175u8, 101u8, 253u8, 252u8],
921            [207u8, 29u8, 107u8, 66u8],
922            [240u8, 67u8, 54u8, 126u8],
923        ];
924    }
925    #[automatically_derived]
926    impl alloy_sol_types::SolInterface for SocketRegistryCalls {
927        const NAME: &'static str = "SocketRegistryCalls";
928        const MIN_DATA_LENGTH: usize = 0usize;
929        const COUNT: usize = 4usize;
930        #[inline]
931        fn selector(&self) -> [u8; 4] {
932            match self {
933                Self::getOperatorSocket(_) => {
934                    <getOperatorSocketCall as alloy_sol_types::SolCall>::SELECTOR
935                }
936                Self::operatorIdToSocket(_) => {
937                    <operatorIdToSocketCall as alloy_sol_types::SolCall>::SELECTOR
938                }
939                Self::setOperatorSocket(_) => {
940                    <setOperatorSocketCall as alloy_sol_types::SolCall>::SELECTOR
941                }
942                Self::slashingRegistryCoordinator(_) => {
943                    <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::SELECTOR
944                }
945            }
946        }
947        #[inline]
948        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
949            Self::SELECTORS.get(i).copied()
950        }
951        #[inline]
952        fn valid_selector(selector: [u8; 4]) -> bool {
953            Self::SELECTORS.binary_search(&selector).is_ok()
954        }
955        #[inline]
956        #[allow(non_snake_case)]
957        fn abi_decode_raw(
958            selector: [u8; 4],
959            data: &[u8],
960        ) -> alloy_sol_types::Result<Self> {
961            static DECODE_SHIMS: &[fn(
962                &[u8],
963            ) -> alloy_sol_types::Result<SocketRegistryCalls>] = &[
964                {
965                    fn getOperatorSocket(
966                        data: &[u8],
967                    ) -> alloy_sol_types::Result<SocketRegistryCalls> {
968                        <getOperatorSocketCall as alloy_sol_types::SolCall>::abi_decode_raw(
969                                data,
970                            )
971                            .map(SocketRegistryCalls::getOperatorSocket)
972                    }
973                    getOperatorSocket
974                },
975                {
976                    fn operatorIdToSocket(
977                        data: &[u8],
978                    ) -> alloy_sol_types::Result<SocketRegistryCalls> {
979                        <operatorIdToSocketCall as alloy_sol_types::SolCall>::abi_decode_raw(
980                                data,
981                            )
982                            .map(SocketRegistryCalls::operatorIdToSocket)
983                    }
984                    operatorIdToSocket
985                },
986                {
987                    fn slashingRegistryCoordinator(
988                        data: &[u8],
989                    ) -> alloy_sol_types::Result<SocketRegistryCalls> {
990                        <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
991                                data,
992                            )
993                            .map(SocketRegistryCalls::slashingRegistryCoordinator)
994                    }
995                    slashingRegistryCoordinator
996                },
997                {
998                    fn setOperatorSocket(
999                        data: &[u8],
1000                    ) -> alloy_sol_types::Result<SocketRegistryCalls> {
1001                        <setOperatorSocketCall as alloy_sol_types::SolCall>::abi_decode_raw(
1002                                data,
1003                            )
1004                            .map(SocketRegistryCalls::setOperatorSocket)
1005                    }
1006                    setOperatorSocket
1007                },
1008            ];
1009            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1010                return Err(
1011                    alloy_sol_types::Error::unknown_selector(
1012                        <Self as alloy_sol_types::SolInterface>::NAME,
1013                        selector,
1014                    ),
1015                );
1016            };
1017            DECODE_SHIMS[idx](data)
1018        }
1019        #[inline]
1020        #[allow(non_snake_case)]
1021        fn abi_decode_raw_validate(
1022            selector: [u8; 4],
1023            data: &[u8],
1024        ) -> alloy_sol_types::Result<Self> {
1025            static DECODE_VALIDATE_SHIMS: &[fn(
1026                &[u8],
1027            ) -> alloy_sol_types::Result<SocketRegistryCalls>] = &[
1028                {
1029                    fn getOperatorSocket(
1030                        data: &[u8],
1031                    ) -> alloy_sol_types::Result<SocketRegistryCalls> {
1032                        <getOperatorSocketCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1033                                data,
1034                            )
1035                            .map(SocketRegistryCalls::getOperatorSocket)
1036                    }
1037                    getOperatorSocket
1038                },
1039                {
1040                    fn operatorIdToSocket(
1041                        data: &[u8],
1042                    ) -> alloy_sol_types::Result<SocketRegistryCalls> {
1043                        <operatorIdToSocketCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1044                                data,
1045                            )
1046                            .map(SocketRegistryCalls::operatorIdToSocket)
1047                    }
1048                    operatorIdToSocket
1049                },
1050                {
1051                    fn slashingRegistryCoordinator(
1052                        data: &[u8],
1053                    ) -> alloy_sol_types::Result<SocketRegistryCalls> {
1054                        <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1055                                data,
1056                            )
1057                            .map(SocketRegistryCalls::slashingRegistryCoordinator)
1058                    }
1059                    slashingRegistryCoordinator
1060                },
1061                {
1062                    fn setOperatorSocket(
1063                        data: &[u8],
1064                    ) -> alloy_sol_types::Result<SocketRegistryCalls> {
1065                        <setOperatorSocketCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1066                                data,
1067                            )
1068                            .map(SocketRegistryCalls::setOperatorSocket)
1069                    }
1070                    setOperatorSocket
1071                },
1072            ];
1073            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1074                return Err(
1075                    alloy_sol_types::Error::unknown_selector(
1076                        <Self as alloy_sol_types::SolInterface>::NAME,
1077                        selector,
1078                    ),
1079                );
1080            };
1081            DECODE_VALIDATE_SHIMS[idx](data)
1082        }
1083        #[inline]
1084        fn abi_encoded_size(&self) -> usize {
1085            match self {
1086                Self::getOperatorSocket(inner) => {
1087                    <getOperatorSocketCall as alloy_sol_types::SolCall>::abi_encoded_size(
1088                        inner,
1089                    )
1090                }
1091                Self::operatorIdToSocket(inner) => {
1092                    <operatorIdToSocketCall as alloy_sol_types::SolCall>::abi_encoded_size(
1093                        inner,
1094                    )
1095                }
1096                Self::setOperatorSocket(inner) => {
1097                    <setOperatorSocketCall as alloy_sol_types::SolCall>::abi_encoded_size(
1098                        inner,
1099                    )
1100                }
1101                Self::slashingRegistryCoordinator(inner) => {
1102                    <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
1103                        inner,
1104                    )
1105                }
1106            }
1107        }
1108        #[inline]
1109        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1110            match self {
1111                Self::getOperatorSocket(inner) => {
1112                    <getOperatorSocketCall as alloy_sol_types::SolCall>::abi_encode_raw(
1113                        inner,
1114                        out,
1115                    )
1116                }
1117                Self::operatorIdToSocket(inner) => {
1118                    <operatorIdToSocketCall as alloy_sol_types::SolCall>::abi_encode_raw(
1119                        inner,
1120                        out,
1121                    )
1122                }
1123                Self::setOperatorSocket(inner) => {
1124                    <setOperatorSocketCall as alloy_sol_types::SolCall>::abi_encode_raw(
1125                        inner,
1126                        out,
1127                    )
1128                }
1129                Self::slashingRegistryCoordinator(inner) => {
1130                    <slashingRegistryCoordinatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
1131                        inner,
1132                        out,
1133                    )
1134                }
1135            }
1136        }
1137    }
1138    ///Container for all the [`SocketRegistry`](self) custom errors.
1139    #[derive(serde::Serialize, serde::Deserialize)]
1140    #[derive(Debug, PartialEq, Eq, Hash)]
1141    pub enum SocketRegistryErrors {
1142        #[allow(missing_docs)]
1143        OnlySlashingRegistryCoordinator(OnlySlashingRegistryCoordinator),
1144    }
1145    #[automatically_derived]
1146    impl SocketRegistryErrors {
1147        /// All the selectors of this enum.
1148        ///
1149        /// Note that the selectors might not be in the same order as the variants.
1150        /// No guarantees are made about the order of the selectors.
1151        ///
1152        /// Prefer using `SolInterface` methods instead.
1153        pub const SELECTORS: &'static [[u8; 4usize]] = &[[176u8, 6u8, 200u8, 20u8]];
1154    }
1155    #[automatically_derived]
1156    impl alloy_sol_types::SolInterface for SocketRegistryErrors {
1157        const NAME: &'static str = "SocketRegistryErrors";
1158        const MIN_DATA_LENGTH: usize = 0usize;
1159        const COUNT: usize = 1usize;
1160        #[inline]
1161        fn selector(&self) -> [u8; 4] {
1162            match self {
1163                Self::OnlySlashingRegistryCoordinator(_) => {
1164                    <OnlySlashingRegistryCoordinator as alloy_sol_types::SolError>::SELECTOR
1165                }
1166            }
1167        }
1168        #[inline]
1169        fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1170            Self::SELECTORS.get(i).copied()
1171        }
1172        #[inline]
1173        fn valid_selector(selector: [u8; 4]) -> bool {
1174            Self::SELECTORS.binary_search(&selector).is_ok()
1175        }
1176        #[inline]
1177        #[allow(non_snake_case)]
1178        fn abi_decode_raw(
1179            selector: [u8; 4],
1180            data: &[u8],
1181        ) -> alloy_sol_types::Result<Self> {
1182            static DECODE_SHIMS: &[fn(
1183                &[u8],
1184            ) -> alloy_sol_types::Result<SocketRegistryErrors>] = &[
1185                {
1186                    fn OnlySlashingRegistryCoordinator(
1187                        data: &[u8],
1188                    ) -> alloy_sol_types::Result<SocketRegistryErrors> {
1189                        <OnlySlashingRegistryCoordinator as alloy_sol_types::SolError>::abi_decode_raw(
1190                                data,
1191                            )
1192                            .map(SocketRegistryErrors::OnlySlashingRegistryCoordinator)
1193                    }
1194                    OnlySlashingRegistryCoordinator
1195                },
1196            ];
1197            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1198                return Err(
1199                    alloy_sol_types::Error::unknown_selector(
1200                        <Self as alloy_sol_types::SolInterface>::NAME,
1201                        selector,
1202                    ),
1203                );
1204            };
1205            DECODE_SHIMS[idx](data)
1206        }
1207        #[inline]
1208        #[allow(non_snake_case)]
1209        fn abi_decode_raw_validate(
1210            selector: [u8; 4],
1211            data: &[u8],
1212        ) -> alloy_sol_types::Result<Self> {
1213            static DECODE_VALIDATE_SHIMS: &[fn(
1214                &[u8],
1215            ) -> alloy_sol_types::Result<SocketRegistryErrors>] = &[
1216                {
1217                    fn OnlySlashingRegistryCoordinator(
1218                        data: &[u8],
1219                    ) -> alloy_sol_types::Result<SocketRegistryErrors> {
1220                        <OnlySlashingRegistryCoordinator as alloy_sol_types::SolError>::abi_decode_raw_validate(
1221                                data,
1222                            )
1223                            .map(SocketRegistryErrors::OnlySlashingRegistryCoordinator)
1224                    }
1225                    OnlySlashingRegistryCoordinator
1226                },
1227            ];
1228            let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1229                return Err(
1230                    alloy_sol_types::Error::unknown_selector(
1231                        <Self as alloy_sol_types::SolInterface>::NAME,
1232                        selector,
1233                    ),
1234                );
1235            };
1236            DECODE_VALIDATE_SHIMS[idx](data)
1237        }
1238        #[inline]
1239        fn abi_encoded_size(&self) -> usize {
1240            match self {
1241                Self::OnlySlashingRegistryCoordinator(inner) => {
1242                    <OnlySlashingRegistryCoordinator as alloy_sol_types::SolError>::abi_encoded_size(
1243                        inner,
1244                    )
1245                }
1246            }
1247        }
1248        #[inline]
1249        fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1250            match self {
1251                Self::OnlySlashingRegistryCoordinator(inner) => {
1252                    <OnlySlashingRegistryCoordinator as alloy_sol_types::SolError>::abi_encode_raw(
1253                        inner,
1254                        out,
1255                    )
1256                }
1257            }
1258        }
1259    }
1260    use alloy::contract as alloy_contract;
1261    /**Creates a new wrapper around an on-chain [`SocketRegistry`](self) contract instance.
1262
1263See the [wrapper's documentation](`SocketRegistryInstance`) for more details.*/
1264    #[inline]
1265    pub const fn new<
1266        P: alloy_contract::private::Provider<N>,
1267        N: alloy_contract::private::Network,
1268    >(
1269        address: alloy_sol_types::private::Address,
1270        provider: P,
1271    ) -> SocketRegistryInstance<P, N> {
1272        SocketRegistryInstance::<P, N>::new(address, provider)
1273    }
1274    /**Deploys this contract using the given `provider` and constructor arguments, if any.
1275
1276Returns a new instance of the contract, if the deployment was successful.
1277
1278For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
1279    #[inline]
1280    pub fn deploy<
1281        P: alloy_contract::private::Provider<N>,
1282        N: alloy_contract::private::Network,
1283    >(
1284        provider: P,
1285        _slashingRegistryCoordinator: alloy::sol_types::private::Address,
1286    ) -> impl ::core::future::Future<
1287        Output = alloy_contract::Result<SocketRegistryInstance<P, N>>,
1288    > {
1289        SocketRegistryInstance::<P, N>::deploy(provider, _slashingRegistryCoordinator)
1290    }
1291    /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
1292and constructor arguments, if any.
1293
1294This is a simple wrapper around creating a `RawCallBuilder` with the data set to
1295the bytecode concatenated with the constructor's ABI-encoded arguments.*/
1296    #[inline]
1297    pub fn deploy_builder<
1298        P: alloy_contract::private::Provider<N>,
1299        N: alloy_contract::private::Network,
1300    >(
1301        provider: P,
1302        _slashingRegistryCoordinator: alloy::sol_types::private::Address,
1303    ) -> alloy_contract::RawCallBuilder<P, N> {
1304        SocketRegistryInstance::<
1305            P,
1306            N,
1307        >::deploy_builder(provider, _slashingRegistryCoordinator)
1308    }
1309    /**A [`SocketRegistry`](self) instance.
1310
1311Contains type-safe methods for interacting with an on-chain instance of the
1312[`SocketRegistry`](self) contract located at a given `address`, using a given
1313provider `P`.
1314
1315If the contract bytecode is available (see the [`sol!`](alloy_sol_types::sol!)
1316documentation on how to provide it), the `deploy` and `deploy_builder` methods can
1317be used to deploy a new instance of the contract.
1318
1319See the [module-level documentation](self) for all the available methods.*/
1320    #[derive(Clone)]
1321    pub struct SocketRegistryInstance<P, N = alloy_contract::private::Ethereum> {
1322        address: alloy_sol_types::private::Address,
1323        provider: P,
1324        _network: ::core::marker::PhantomData<N>,
1325    }
1326    #[automatically_derived]
1327    impl<P, N> ::core::fmt::Debug for SocketRegistryInstance<P, N> {
1328        #[inline]
1329        fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1330            f.debug_tuple("SocketRegistryInstance").field(&self.address).finish()
1331        }
1332    }
1333    /// Instantiation and getters/setters.
1334    #[automatically_derived]
1335    impl<
1336        P: alloy_contract::private::Provider<N>,
1337        N: alloy_contract::private::Network,
1338    > SocketRegistryInstance<P, N> {
1339        /**Creates a new wrapper around an on-chain [`SocketRegistry`](self) contract instance.
1340
1341See the [wrapper's documentation](`SocketRegistryInstance`) for more details.*/
1342        #[inline]
1343        pub const fn new(
1344            address: alloy_sol_types::private::Address,
1345            provider: P,
1346        ) -> Self {
1347            Self {
1348                address,
1349                provider,
1350                _network: ::core::marker::PhantomData,
1351            }
1352        }
1353        /**Deploys this contract using the given `provider` and constructor arguments, if any.
1354
1355Returns a new instance of the contract, if the deployment was successful.
1356
1357For more fine-grained control over the deployment process, use [`deploy_builder`] instead.*/
1358        #[inline]
1359        pub async fn deploy(
1360            provider: P,
1361            _slashingRegistryCoordinator: alloy::sol_types::private::Address,
1362        ) -> alloy_contract::Result<SocketRegistryInstance<P, N>> {
1363            let call_builder = Self::deploy_builder(
1364                provider,
1365                _slashingRegistryCoordinator,
1366            );
1367            let contract_address = call_builder.deploy().await?;
1368            Ok(Self::new(contract_address, call_builder.provider))
1369        }
1370        /**Creates a `RawCallBuilder` for deploying this contract using the given `provider`
1371and constructor arguments, if any.
1372
1373This is a simple wrapper around creating a `RawCallBuilder` with the data set to
1374the bytecode concatenated with the constructor's ABI-encoded arguments.*/
1375        #[inline]
1376        pub fn deploy_builder(
1377            provider: P,
1378            _slashingRegistryCoordinator: alloy::sol_types::private::Address,
1379        ) -> alloy_contract::RawCallBuilder<P, N> {
1380            alloy_contract::RawCallBuilder::new_raw_deploy(
1381                provider,
1382                [
1383                    &BYTECODE[..],
1384                    &alloy_sol_types::SolConstructor::abi_encode(
1385                        &constructorCall {
1386                            _slashingRegistryCoordinator,
1387                        },
1388                    )[..],
1389                ]
1390                    .concat()
1391                    .into(),
1392            )
1393        }
1394        /// Returns a reference to the address.
1395        #[inline]
1396        pub const fn address(&self) -> &alloy_sol_types::private::Address {
1397            &self.address
1398        }
1399        /// Sets the address.
1400        #[inline]
1401        pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
1402            self.address = address;
1403        }
1404        /// Sets the address and returns `self`.
1405        pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
1406            self.set_address(address);
1407            self
1408        }
1409        /// Returns a reference to the provider.
1410        #[inline]
1411        pub const fn provider(&self) -> &P {
1412            &self.provider
1413        }
1414    }
1415    impl<P: ::core::clone::Clone, N> SocketRegistryInstance<&P, N> {
1416        /// Clones the provider and returns a new instance with the cloned provider.
1417        #[inline]
1418        pub fn with_cloned_provider(self) -> SocketRegistryInstance<P, N> {
1419            SocketRegistryInstance {
1420                address: self.address,
1421                provider: ::core::clone::Clone::clone(&self.provider),
1422                _network: ::core::marker::PhantomData,
1423            }
1424        }
1425    }
1426    /// Function calls.
1427    #[automatically_derived]
1428    impl<
1429        P: alloy_contract::private::Provider<N>,
1430        N: alloy_contract::private::Network,
1431    > SocketRegistryInstance<P, N> {
1432        /// Creates a new call builder using this contract instance's provider and address.
1433        ///
1434        /// Note that the call can be any function call, not just those defined in this
1435        /// contract. Prefer using the other methods for building type-safe contract calls.
1436        pub fn call_builder<C: alloy_sol_types::SolCall>(
1437            &self,
1438            call: &C,
1439        ) -> alloy_contract::SolCallBuilder<&P, C, N> {
1440            alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
1441        }
1442        ///Creates a new call builder for the [`getOperatorSocket`] function.
1443        pub fn getOperatorSocket(
1444            &self,
1445            _operatorId: alloy::sol_types::private::FixedBytes<32>,
1446        ) -> alloy_contract::SolCallBuilder<&P, getOperatorSocketCall, N> {
1447            self.call_builder(
1448                &getOperatorSocketCall {
1449                    _operatorId,
1450                },
1451            )
1452        }
1453        ///Creates a new call builder for the [`operatorIdToSocket`] function.
1454        pub fn operatorIdToSocket(
1455            &self,
1456            _0: alloy::sol_types::private::FixedBytes<32>,
1457        ) -> alloy_contract::SolCallBuilder<&P, operatorIdToSocketCall, N> {
1458            self.call_builder(&operatorIdToSocketCall(_0))
1459        }
1460        ///Creates a new call builder for the [`setOperatorSocket`] function.
1461        pub fn setOperatorSocket(
1462            &self,
1463            _operatorId: alloy::sol_types::private::FixedBytes<32>,
1464            _socket: alloy::sol_types::private::String,
1465        ) -> alloy_contract::SolCallBuilder<&P, setOperatorSocketCall, N> {
1466            self.call_builder(
1467                &setOperatorSocketCall {
1468                    _operatorId,
1469                    _socket,
1470                },
1471            )
1472        }
1473        ///Creates a new call builder for the [`slashingRegistryCoordinator`] function.
1474        pub fn slashingRegistryCoordinator(
1475            &self,
1476        ) -> alloy_contract::SolCallBuilder<&P, slashingRegistryCoordinatorCall, N> {
1477            self.call_builder(&slashingRegistryCoordinatorCall)
1478        }
1479    }
1480    /// Event filters.
1481    #[automatically_derived]
1482    impl<
1483        P: alloy_contract::private::Provider<N>,
1484        N: alloy_contract::private::Network,
1485    > SocketRegistryInstance<P, N> {
1486        /// Creates a new event filter using this contract instance's provider and address.
1487        ///
1488        /// Note that the type can be any event, not just those defined in this contract.
1489        /// Prefer using the other methods for building type-safe event filters.
1490        pub fn event_filter<E: alloy_sol_types::SolEvent>(
1491            &self,
1492        ) -> alloy_contract::Event<&P, E, N> {
1493            alloy_contract::Event::new_sol(&self.provider, &self.address)
1494        }
1495    }
1496}
eigenlayer_contract_deployer/bindings/core/socket_registry.rs

eigenlayer_contract_deployer/bindings/core/
socket_registry.rs
