1#[allow(
270 non_camel_case_types,
271 non_snake_case,
272 clippy::pub_underscore_fields,
273 clippy::style,
274 clippy::empty_structs_with_brackets
275)]
276pub mod HoprDummyProxyForNetworkRegistry {
277 use super::*;
278 use alloy::sol_types as alloy_sol_types;
279 #[rustfmt::skip]
285 #[allow(clippy::all)]
286 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
287 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x07\xC48\x03\x80a\x07\xC4\x839\x81\x01`@\x81\x90Ra\0/\x91a\0\xD5V[a\083a\0\x85V[a\0A\x81a\0\x85V[`\x02\x80T`\xFF\x19\x16\x90U`@Q`\0\x81R\x7F\xAF\xAB#\xA4\xBC\x8CI%\x0B\xA3~\xEB\x06%\xB0\xA9\xB2q\xF5]\x15\x01\x83\x8D$\xF5E\x08\xC3\xB1sB\x90` \x01`@Q\x80\x91\x03\x90\xA1Pa\x01\x05V[`\0\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[`\0` \x82\x84\x03\x12\x15a\0\xE7W`\0\x80\xFD[\x81Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\0\xFEW`\0\x80\xFD[\x93\x92PPPV[a\x06\xB0\x80a\x01\x14`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xB4W`\x005`\xE0\x1C\x80c\xA7\x1B\x1Bt\x11a\0qW\x80c\xA7\x1B\x1Bt\x14a\x01/W\x80c\xB3TN\x82\x14a\x01BW\x80c\xD8Z\xD0D\x14a\x01cW\x80c\xF2\xFD\xE3\x8B\x14a\x01\x89W\x80c\xF4l\x84\xB8\x14a\x01\x9CW\x80c\xF6\x7F^o\x14a\x01\xA5W`\0\x80\xFD[\x80c\x08\x9F\xFAG\x14a\0\xB9W\x80c@Q\xF2W\x14a\0\xCEW\x80cHcT\xE2\x14a\0\xE1W\x80c\\Tq\xE7\x14a\0\xF4W\x80cqP\x18\xA6\x14a\x01\x07W\x80c\x8D\xA5\xCB[\x14a\x01\x0FW[`\0\x80\xFD[a\0\xCCa\0\xC76`\x04a\x05:V[a\x01\xB2V[\0[a\0\xCCa\0\xDC6`\x04a\x05zV[a\x02\x12V[a\0\xCCa\0\xEF6`\x04a\x05\x95V[a\x02#V[a\0\xCCa\x01\x026`\x04a\x05\x95V[a\x02|V[a\0\xCCa\x02\xD0V[`\0T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xCCa\x01=6`\x04a\x05zV[a\x02\xE4V[a\x01Ua\x01P6`\x04a\x05zV[a\x02\xF5V[`@Q\x90\x81R` \x01a\x01&V[a\x01ya\x01q6`\x04a\x06\nV[`\x01\x92\x91PPV[`@Q\x90\x15\x15\x81R` \x01a\x01&V[a\0\xCCa\x01\x976`\x04a\x05zV[a\x03<V[a\x01U`\0\x19\x81V[`\x02Ta\x01y\x90`\xFF\x16\x81V[a\x01\xBAa\x03\xB7V[`\x02T`\xFF\x16\x15\x15\x81\x15\x15\x14a\x02\x0FW`\x02\x80T`\xFF\x19\x16\x82\x15\x15\x90\x81\x17\x90\x91U`@Q\x90\x81R\x7F\xAF\xAB#\xA4\xBC\x8CI%\x0B\xA3~\xEB\x06%\xB0\xA9\xB2q\xF5]\x15\x01\x83\x8D$\xF5E\x08\xC3\xB1sB\x90` \x01`@Q\x80\x91\x03\x90\xA1[PV[a\x02\x1Aa\x03\xB7V[a\x02\x0F\x81a\x04\x11V[a\x02+a\x03\xB7V[`\0[\x81\x81\x10\x15a\x02wWa\x02e\x83\x83\x83\x81\x81\x10a\x02KWa\x02Ka\x06=V[\x90P` \x02\x01` \x81\x01\x90a\x02`\x91\x90a\x05zV[a\x04{V[\x80a\x02o\x81a\x06SV[\x91PPa\x02.V[PPPV[a\x02\x84a\x03\xB7V[`\0[\x81\x81\x10\x15a\x02wWa\x02\xBE\x83\x83\x83\x81\x81\x10a\x02\xA4Wa\x02\xA4a\x06=V[\x90P` \x02\x01` \x81\x01\x90a\x02\xB9\x91\x90a\x05zV[a\x04\x11V[\x80a\x02\xC8\x81a\x06SV[\x91PPa\x02\x87V[a\x02\xD8a\x03\xB7V[a\x02\xE2`\0a\x04\xEAV[V[a\x02\xECa\x03\xB7V[a\x02\x0F\x81a\x04{V[`\x02T`\0\x90`\xFF\x16\x80a\x03!WP`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x01` R`@\x90 T`\xFF\x16[\x15a\x03/WP`\0\x19\x91\x90PV[P`\0\x91\x90PV[\x91\x90PV[a\x03Da\x03\xB7V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x03\xAEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01Reddress`\xD0\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[a\x02\x0F\x81a\x04\xEAV[`\0T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x02\xE2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xA5V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x01` R`@\x90 T`\xFF\x16\x15a\x02\x0FW`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x81\x81R`\x01` R`@\x80\x82 \x80T`\xFF\x19\x16\x90UQ\x7F\x0Ec\xD6)\xAF\xE3K<\xA5\x10|\x10\xF9\n\xBF\xF5\t\x1B1U\x1B7\x17X\xBDP\xAFv\x83M\xC0t\x91\x90\xA2PV[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x01` R`@\x90 T`\xFF\x16a\x02\x0FW`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x81\x81R`\x01` \x81\x90R`@\x80\x83 \x80T`\xFF\x19\x16\x90\x92\x17\x90\x91UQ\x7F\xCD\x82-\xC9h\x8E \xAC\xEAhrJ/\xBC\xFEO>Rm \xEC\xAA7\xB1\x8F\xE3\x04z\xB3w\xD6\xA5\x91\x90\xA2PV[`\0\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[`\0` \x82\x84\x03\x12\x15a\x05LW`\0\x80\xFD[\x815\x80\x15\x15\x81\x14a\x05\\W`\0\x80\xFD[\x93\x92PPPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x037W`\0\x80\xFD[`\0` \x82\x84\x03\x12\x15a\x05\x8CW`\0\x80\xFD[a\x05\\\x82a\x05cV[`\0\x80` \x83\x85\x03\x12\x15a\x05\xA8W`\0\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x05\xC0W`\0\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x05\xD4W`\0\x80\xFD[\x815\x81\x81\x11\x15a\x05\xE3W`\0\x80\xFD[\x86` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x05\xF8W`\0\x80\xFD[` \x92\x90\x92\x01\x96\x91\x95P\x90\x93PPPPV[`\0\x80`@\x83\x85\x03\x12\x15a\x06\x1DW`\0\x80\xFD[a\x06&\x83a\x05cV[\x91Pa\x064` \x84\x01a\x05cV[\x90P\x92P\x92\x90PV[cNH{q`\xE0\x1B`\0R`2`\x04R`$`\0\xFD[`\0`\x01\x82\x01a\x06sWcNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[P`\x01\x01\x90V\xFE\xA2dipfsX\"\x12 \x17\xF8\x85\xC4\xB1\x04C\"\xC6\xEB\r\xB8\x81\xF1\xDA\xE8L\xDB\x938\x95(\x1A\x13}\xF6\x7FF\xE2T\rldsolcC\0\x08\x13\x003",
288 );
289 #[rustfmt::skip]
295 #[allow(clippy::all)]
296 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
297 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0\xB4W`\x005`\xE0\x1C\x80c\xA7\x1B\x1Bt\x11a\0qW\x80c\xA7\x1B\x1Bt\x14a\x01/W\x80c\xB3TN\x82\x14a\x01BW\x80c\xD8Z\xD0D\x14a\x01cW\x80c\xF2\xFD\xE3\x8B\x14a\x01\x89W\x80c\xF4l\x84\xB8\x14a\x01\x9CW\x80c\xF6\x7F^o\x14a\x01\xA5W`\0\x80\xFD[\x80c\x08\x9F\xFAG\x14a\0\xB9W\x80c@Q\xF2W\x14a\0\xCEW\x80cHcT\xE2\x14a\0\xE1W\x80c\\Tq\xE7\x14a\0\xF4W\x80cqP\x18\xA6\x14a\x01\x07W\x80c\x8D\xA5\xCB[\x14a\x01\x0FW[`\0\x80\xFD[a\0\xCCa\0\xC76`\x04a\x05:V[a\x01\xB2V[\0[a\0\xCCa\0\xDC6`\x04a\x05zV[a\x02\x12V[a\0\xCCa\0\xEF6`\x04a\x05\x95V[a\x02#V[a\0\xCCa\x01\x026`\x04a\x05\x95V[a\x02|V[a\0\xCCa\x02\xD0V[`\0T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xCCa\x01=6`\x04a\x05zV[a\x02\xE4V[a\x01Ua\x01P6`\x04a\x05zV[a\x02\xF5V[`@Q\x90\x81R` \x01a\x01&V[a\x01ya\x01q6`\x04a\x06\nV[`\x01\x92\x91PPV[`@Q\x90\x15\x15\x81R` \x01a\x01&V[a\0\xCCa\x01\x976`\x04a\x05zV[a\x03<V[a\x01U`\0\x19\x81V[`\x02Ta\x01y\x90`\xFF\x16\x81V[a\x01\xBAa\x03\xB7V[`\x02T`\xFF\x16\x15\x15\x81\x15\x15\x14a\x02\x0FW`\x02\x80T`\xFF\x19\x16\x82\x15\x15\x90\x81\x17\x90\x91U`@Q\x90\x81R\x7F\xAF\xAB#\xA4\xBC\x8CI%\x0B\xA3~\xEB\x06%\xB0\xA9\xB2q\xF5]\x15\x01\x83\x8D$\xF5E\x08\xC3\xB1sB\x90` \x01`@Q\x80\x91\x03\x90\xA1[PV[a\x02\x1Aa\x03\xB7V[a\x02\x0F\x81a\x04\x11V[a\x02+a\x03\xB7V[`\0[\x81\x81\x10\x15a\x02wWa\x02e\x83\x83\x83\x81\x81\x10a\x02KWa\x02Ka\x06=V[\x90P` \x02\x01` \x81\x01\x90a\x02`\x91\x90a\x05zV[a\x04{V[\x80a\x02o\x81a\x06SV[\x91PPa\x02.V[PPPV[a\x02\x84a\x03\xB7V[`\0[\x81\x81\x10\x15a\x02wWa\x02\xBE\x83\x83\x83\x81\x81\x10a\x02\xA4Wa\x02\xA4a\x06=V[\x90P` \x02\x01` \x81\x01\x90a\x02\xB9\x91\x90a\x05zV[a\x04\x11V[\x80a\x02\xC8\x81a\x06SV[\x91PPa\x02\x87V[a\x02\xD8a\x03\xB7V[a\x02\xE2`\0a\x04\xEAV[V[a\x02\xECa\x03\xB7V[a\x02\x0F\x81a\x04{V[`\x02T`\0\x90`\xFF\x16\x80a\x03!WP`\x01`\x01`\xA0\x1B\x03\x82\x16`\0\x90\x81R`\x01` R`@\x90 T`\xFF\x16[\x15a\x03/WP`\0\x19\x91\x90PV[P`\0\x91\x90PV[\x91\x90PV[a\x03Da\x03\xB7V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x03\xAEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`&`$\x82\x01R\x7FOwnable: new owner is the zero a`D\x82\x01Reddress`\xD0\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[a\x02\x0F\x81a\x04\xEAV[`\0T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x02\xE2W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x03\xA5V[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x01` R`@\x90 T`\xFF\x16\x15a\x02\x0FW`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x81\x81R`\x01` R`@\x80\x82 \x80T`\xFF\x19\x16\x90UQ\x7F\x0Ec\xD6)\xAF\xE3K<\xA5\x10|\x10\xF9\n\xBF\xF5\t\x1B1U\x1B7\x17X\xBDP\xAFv\x83M\xC0t\x91\x90\xA2PV[`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x90\x81R`\x01` R`@\x90 T`\xFF\x16a\x02\x0FW`\x01`\x01`\xA0\x1B\x03\x81\x16`\0\x81\x81R`\x01` \x81\x90R`@\x80\x83 \x80T`\xFF\x19\x16\x90\x92\x17\x90\x91UQ\x7F\xCD\x82-\xC9h\x8E \xAC\xEAhrJ/\xBC\xFEO>Rm \xEC\xAA7\xB1\x8F\xE3\x04z\xB3w\xD6\xA5\x91\x90\xA2PV[`\0\x80T`\x01`\x01`\xA0\x1B\x03\x83\x81\x16`\x01`\x01`\xA0\x1B\x03\x19\x83\x16\x81\x17\x84U`@Q\x91\x90\x92\x16\x92\x83\x91\x7F\x8B\xE0\x07\x9CS\x16Y\x14\x13D\xCD\x1F\xD0\xA4\xF2\x84\x19I\x7F\x97\"\xA3\xDA\xAF\xE3\xB4\x18okdW\xE0\x91\x90\xA3PPV[`\0` \x82\x84\x03\x12\x15a\x05LW`\0\x80\xFD[\x815\x80\x15\x15\x81\x14a\x05\\W`\0\x80\xFD[\x93\x92PPPV[\x805`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x037W`\0\x80\xFD[`\0` \x82\x84\x03\x12\x15a\x05\x8CW`\0\x80\xFD[a\x05\\\x82a\x05cV[`\0\x80` \x83\x85\x03\x12\x15a\x05\xA8W`\0\x80\xFD[\x825g\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x82\x11\x15a\x05\xC0W`\0\x80\xFD[\x81\x85\x01\x91P\x85`\x1F\x83\x01\x12a\x05\xD4W`\0\x80\xFD[\x815\x81\x81\x11\x15a\x05\xE3W`\0\x80\xFD[\x86` \x82`\x05\x1B\x85\x01\x01\x11\x15a\x05\xF8W`\0\x80\xFD[` \x92\x90\x92\x01\x96\x91\x95P\x90\x93PPPPV[`\0\x80`@\x83\x85\x03\x12\x15a\x06\x1DW`\0\x80\xFD[a\x06&\x83a\x05cV[\x91Pa\x064` \x84\x01a\x05cV[\x90P\x92P\x92\x90PV[cNH{q`\xE0\x1B`\0R`2`\x04R`$`\0\xFD[`\0`\x01\x82\x01a\x06sWcNH{q`\xE0\x1B`\0R`\x11`\x04R`$`\0\xFD[P`\x01\x01\x90V\xFE\xA2dipfsX\"\x12 \x17\xF8\x85\xC4\xB1\x04C\"\xC6\xEB\r\xB8\x81\xF1\xDA\xE8L\xDB\x938\x95(\x1A\x13}\xF6\x7FF\xE2T\rldsolcC\0\x08\x13\x003",
298 );
299 #[derive(serde::Serialize, serde::Deserialize)]
300 #[derive(Default, Debug, PartialEq, Eq, Hash)]
301 #[allow(
306 non_camel_case_types,
307 non_snake_case,
308 clippy::pub_underscore_fields,
309 clippy::style
310 )]
311 #[derive(Clone)]
312 pub struct AccountDeregistered {
313 #[allow(missing_docs)]
314 pub account: alloy::sol_types::private::Address,
315 }
316 #[allow(
317 non_camel_case_types,
318 non_snake_case,
319 clippy::pub_underscore_fields,
320 clippy::style
321 )]
322 const _: () = {
323 use alloy::sol_types as alloy_sol_types;
324 #[automatically_derived]
325 impl alloy_sol_types::SolEvent for AccountDeregistered {
326 type DataTuple<'a> = ();
327 type DataToken<'a> = <Self::DataTuple<
328 'a,
329 > as alloy_sol_types::SolType>::Token<'a>;
330 type TopicList = (
331 alloy_sol_types::sol_data::FixedBytes<32>,
332 alloy::sol_types::sol_data::Address,
333 );
334 const SIGNATURE: &'static str = "AccountDeregistered(address)";
335 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
336 14u8, 99u8, 214u8, 41u8, 175u8, 227u8, 75u8, 60u8, 165u8, 16u8, 124u8,
337 16u8, 249u8, 10u8, 191u8, 245u8, 9u8, 27u8, 49u8, 85u8, 27u8, 55u8, 23u8,
338 88u8, 189u8, 80u8, 175u8, 118u8, 131u8, 77u8, 192u8, 116u8,
339 ]);
340 const ANONYMOUS: bool = false;
341 #[allow(unused_variables)]
342 #[inline]
343 fn new(
344 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
345 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
346 ) -> Self {
347 Self { account: topics.1 }
348 }
349 #[inline]
350 fn check_signature(
351 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
352 ) -> alloy_sol_types::Result<()> {
353 if topics.0 != Self::SIGNATURE_HASH {
354 return Err(
355 alloy_sol_types::Error::invalid_event_signature_hash(
356 Self::SIGNATURE,
357 topics.0,
358 Self::SIGNATURE_HASH,
359 ),
360 );
361 }
362 Ok(())
363 }
364 #[inline]
365 fn tokenize_body(&self) -> Self::DataToken<'_> {
366 ()
367 }
368 #[inline]
369 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
370 (Self::SIGNATURE_HASH.into(), self.account.clone())
371 }
372 #[inline]
373 fn encode_topics_raw(
374 &self,
375 out: &mut [alloy_sol_types::abi::token::WordToken],
376 ) -> alloy_sol_types::Result<()> {
377 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
378 return Err(alloy_sol_types::Error::Overrun);
379 }
380 out[0usize] = alloy_sol_types::abi::token::WordToken(
381 Self::SIGNATURE_HASH,
382 );
383 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
384 &self.account,
385 );
386 Ok(())
387 }
388 }
389 #[automatically_derived]
390 impl alloy_sol_types::private::IntoLogData for AccountDeregistered {
391 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
392 From::from(self)
393 }
394 fn into_log_data(self) -> alloy_sol_types::private::LogData {
395 From::from(&self)
396 }
397 }
398 #[automatically_derived]
399 impl From<&AccountDeregistered> for alloy_sol_types::private::LogData {
400 #[inline]
401 fn from(this: &AccountDeregistered) -> alloy_sol_types::private::LogData {
402 alloy_sol_types::SolEvent::encode_log_data(this)
403 }
404 }
405 };
406 #[derive(serde::Serialize, serde::Deserialize)]
407 #[derive(Default, Debug, PartialEq, Eq, Hash)]
408 #[allow(
413 non_camel_case_types,
414 non_snake_case,
415 clippy::pub_underscore_fields,
416 clippy::style
417 )]
418 #[derive(Clone)]
419 pub struct AccountRegistered {
420 #[allow(missing_docs)]
421 pub account: alloy::sol_types::private::Address,
422 }
423 #[allow(
424 non_camel_case_types,
425 non_snake_case,
426 clippy::pub_underscore_fields,
427 clippy::style
428 )]
429 const _: () = {
430 use alloy::sol_types as alloy_sol_types;
431 #[automatically_derived]
432 impl alloy_sol_types::SolEvent for AccountRegistered {
433 type DataTuple<'a> = ();
434 type DataToken<'a> = <Self::DataTuple<
435 'a,
436 > as alloy_sol_types::SolType>::Token<'a>;
437 type TopicList = (
438 alloy_sol_types::sol_data::FixedBytes<32>,
439 alloy::sol_types::sol_data::Address,
440 );
441 const SIGNATURE: &'static str = "AccountRegistered(address)";
442 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
443 205u8, 130u8, 45u8, 201u8, 104u8, 142u8, 32u8, 172u8, 234u8, 104u8,
444 114u8, 74u8, 47u8, 188u8, 254u8, 79u8, 62u8, 82u8, 109u8, 32u8, 236u8,
445 170u8, 55u8, 177u8, 143u8, 227u8, 4u8, 122u8, 179u8, 119u8, 214u8, 165u8,
446 ]);
447 const ANONYMOUS: bool = false;
448 #[allow(unused_variables)]
449 #[inline]
450 fn new(
451 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
452 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
453 ) -> Self {
454 Self { account: topics.1 }
455 }
456 #[inline]
457 fn check_signature(
458 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
459 ) -> alloy_sol_types::Result<()> {
460 if topics.0 != Self::SIGNATURE_HASH {
461 return Err(
462 alloy_sol_types::Error::invalid_event_signature_hash(
463 Self::SIGNATURE,
464 topics.0,
465 Self::SIGNATURE_HASH,
466 ),
467 );
468 }
469 Ok(())
470 }
471 #[inline]
472 fn tokenize_body(&self) -> Self::DataToken<'_> {
473 ()
474 }
475 #[inline]
476 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
477 (Self::SIGNATURE_HASH.into(), self.account.clone())
478 }
479 #[inline]
480 fn encode_topics_raw(
481 &self,
482 out: &mut [alloy_sol_types::abi::token::WordToken],
483 ) -> alloy_sol_types::Result<()> {
484 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
485 return Err(alloy_sol_types::Error::Overrun);
486 }
487 out[0usize] = alloy_sol_types::abi::token::WordToken(
488 Self::SIGNATURE_HASH,
489 );
490 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
491 &self.account,
492 );
493 Ok(())
494 }
495 }
496 #[automatically_derived]
497 impl alloy_sol_types::private::IntoLogData for AccountRegistered {
498 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
499 From::from(self)
500 }
501 fn into_log_data(self) -> alloy_sol_types::private::LogData {
502 From::from(&self)
503 }
504 }
505 #[automatically_derived]
506 impl From<&AccountRegistered> for alloy_sol_types::private::LogData {
507 #[inline]
508 fn from(this: &AccountRegistered) -> alloy_sol_types::private::LogData {
509 alloy_sol_types::SolEvent::encode_log_data(this)
510 }
511 }
512 };
513 #[derive(serde::Serialize, serde::Deserialize)]
514 #[derive(Default, Debug, PartialEq, Eq, Hash)]
515 #[allow(
520 non_camel_case_types,
521 non_snake_case,
522 clippy::pub_underscore_fields,
523 clippy::style
524 )]
525 #[derive(Clone)]
526 pub struct AllowAllAccountsEligible {
527 #[allow(missing_docs)]
528 pub isAllowed: bool,
529 }
530 #[allow(
531 non_camel_case_types,
532 non_snake_case,
533 clippy::pub_underscore_fields,
534 clippy::style
535 )]
536 const _: () = {
537 use alloy::sol_types as alloy_sol_types;
538 #[automatically_derived]
539 impl alloy_sol_types::SolEvent for AllowAllAccountsEligible {
540 type DataTuple<'a> = (alloy::sol_types::sol_data::Bool,);
541 type DataToken<'a> = <Self::DataTuple<
542 'a,
543 > as alloy_sol_types::SolType>::Token<'a>;
544 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
545 const SIGNATURE: &'static str = "AllowAllAccountsEligible(bool)";
546 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
547 175u8, 171u8, 35u8, 164u8, 188u8, 140u8, 73u8, 37u8, 11u8, 163u8, 126u8,
548 235u8, 6u8, 37u8, 176u8, 169u8, 178u8, 113u8, 245u8, 93u8, 21u8, 1u8,
549 131u8, 141u8, 36u8, 245u8, 69u8, 8u8, 195u8, 177u8, 115u8, 66u8,
550 ]);
551 const ANONYMOUS: bool = false;
552 #[allow(unused_variables)]
553 #[inline]
554 fn new(
555 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
556 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
557 ) -> Self {
558 Self { isAllowed: data.0 }
559 }
560 #[inline]
561 fn check_signature(
562 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
563 ) -> alloy_sol_types::Result<()> {
564 if topics.0 != Self::SIGNATURE_HASH {
565 return Err(
566 alloy_sol_types::Error::invalid_event_signature_hash(
567 Self::SIGNATURE,
568 topics.0,
569 Self::SIGNATURE_HASH,
570 ),
571 );
572 }
573 Ok(())
574 }
575 #[inline]
576 fn tokenize_body(&self) -> Self::DataToken<'_> {
577 (
578 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
579 &self.isAllowed,
580 ),
581 )
582 }
583 #[inline]
584 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
585 (Self::SIGNATURE_HASH.into(),)
586 }
587 #[inline]
588 fn encode_topics_raw(
589 &self,
590 out: &mut [alloy_sol_types::abi::token::WordToken],
591 ) -> alloy_sol_types::Result<()> {
592 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
593 return Err(alloy_sol_types::Error::Overrun);
594 }
595 out[0usize] = alloy_sol_types::abi::token::WordToken(
596 Self::SIGNATURE_HASH,
597 );
598 Ok(())
599 }
600 }
601 #[automatically_derived]
602 impl alloy_sol_types::private::IntoLogData for AllowAllAccountsEligible {
603 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
604 From::from(self)
605 }
606 fn into_log_data(self) -> alloy_sol_types::private::LogData {
607 From::from(&self)
608 }
609 }
610 #[automatically_derived]
611 impl From<&AllowAllAccountsEligible> for alloy_sol_types::private::LogData {
612 #[inline]
613 fn from(
614 this: &AllowAllAccountsEligible,
615 ) -> alloy_sol_types::private::LogData {
616 alloy_sol_types::SolEvent::encode_log_data(this)
617 }
618 }
619 };
620 #[derive(serde::Serialize, serde::Deserialize)]
621 #[derive(Default, Debug, PartialEq, Eq, Hash)]
622 #[allow(
627 non_camel_case_types,
628 non_snake_case,
629 clippy::pub_underscore_fields,
630 clippy::style
631 )]
632 #[derive(Clone)]
633 pub struct OwnershipTransferred {
634 #[allow(missing_docs)]
635 pub previousOwner: alloy::sol_types::private::Address,
636 #[allow(missing_docs)]
637 pub newOwner: alloy::sol_types::private::Address,
638 }
639 #[allow(
640 non_camel_case_types,
641 non_snake_case,
642 clippy::pub_underscore_fields,
643 clippy::style
644 )]
645 const _: () = {
646 use alloy::sol_types as alloy_sol_types;
647 #[automatically_derived]
648 impl alloy_sol_types::SolEvent for OwnershipTransferred {
649 type DataTuple<'a> = ();
650 type DataToken<'a> = <Self::DataTuple<
651 'a,
652 > as alloy_sol_types::SolType>::Token<'a>;
653 type TopicList = (
654 alloy_sol_types::sol_data::FixedBytes<32>,
655 alloy::sol_types::sol_data::Address,
656 alloy::sol_types::sol_data::Address,
657 );
658 const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
659 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
660 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
661 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
662 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
663 ]);
664 const ANONYMOUS: bool = false;
665 #[allow(unused_variables)]
666 #[inline]
667 fn new(
668 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
669 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
670 ) -> Self {
671 Self {
672 previousOwner: topics.1,
673 newOwner: topics.2,
674 }
675 }
676 #[inline]
677 fn check_signature(
678 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
679 ) -> alloy_sol_types::Result<()> {
680 if topics.0 != Self::SIGNATURE_HASH {
681 return Err(
682 alloy_sol_types::Error::invalid_event_signature_hash(
683 Self::SIGNATURE,
684 topics.0,
685 Self::SIGNATURE_HASH,
686 ),
687 );
688 }
689 Ok(())
690 }
691 #[inline]
692 fn tokenize_body(&self) -> Self::DataToken<'_> {
693 ()
694 }
695 #[inline]
696 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
697 (
698 Self::SIGNATURE_HASH.into(),
699 self.previousOwner.clone(),
700 self.newOwner.clone(),
701 )
702 }
703 #[inline]
704 fn encode_topics_raw(
705 &self,
706 out: &mut [alloy_sol_types::abi::token::WordToken],
707 ) -> alloy_sol_types::Result<()> {
708 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
709 return Err(alloy_sol_types::Error::Overrun);
710 }
711 out[0usize] = alloy_sol_types::abi::token::WordToken(
712 Self::SIGNATURE_HASH,
713 );
714 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
715 &self.previousOwner,
716 );
717 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
718 &self.newOwner,
719 );
720 Ok(())
721 }
722 }
723 #[automatically_derived]
724 impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
725 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
726 From::from(self)
727 }
728 fn into_log_data(self) -> alloy_sol_types::private::LogData {
729 From::from(&self)
730 }
731 }
732 #[automatically_derived]
733 impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
734 #[inline]
735 fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
736 alloy_sol_types::SolEvent::encode_log_data(this)
737 }
738 }
739 };
740 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
745 #[derive(Clone)]
746 pub struct constructorCall {
747 #[allow(missing_docs)]
748 pub newOwner: alloy::sol_types::private::Address,
749 }
750 const _: () = {
751 use alloy::sol_types as alloy_sol_types;
752 {
753 #[doc(hidden)]
754 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
755 #[doc(hidden)]
756 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
757 #[cfg(test)]
758 #[allow(dead_code, unreachable_patterns)]
759 fn _type_assertion(
760 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
761 ) {
762 match _t {
763 alloy_sol_types::private::AssertTypeEq::<
764 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
765 >(_) => {}
766 }
767 }
768 #[automatically_derived]
769 #[doc(hidden)]
770 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
771 fn from(value: constructorCall) -> Self {
772 (value.newOwner,)
773 }
774 }
775 #[automatically_derived]
776 #[doc(hidden)]
777 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
778 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
779 Self { newOwner: tuple.0 }
780 }
781 }
782 }
783 #[automatically_derived]
784 impl alloy_sol_types::SolConstructor for constructorCall {
785 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
786 type Token<'a> = <Self::Parameters<
787 'a,
788 > as alloy_sol_types::SolType>::Token<'a>;
789 #[inline]
790 fn new<'a>(
791 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
792 ) -> Self {
793 tuple.into()
794 }
795 #[inline]
796 fn tokenize(&self) -> Self::Token<'_> {
797 (
798 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
799 &self.newOwner,
800 ),
801 )
802 }
803 }
804 };
805 #[derive(serde::Serialize, serde::Deserialize)]
806 #[derive(Default, Debug, PartialEq, Eq, Hash)]
807 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
812 #[derive(Clone)]
813 pub struct MAX_REGISTRATION_PER_ACCOUNTCall;
814 #[derive(serde::Serialize, serde::Deserialize)]
815 #[derive(Default, Debug, PartialEq, Eq, Hash)]
816 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
818 #[derive(Clone)]
819 pub struct MAX_REGISTRATION_PER_ACCOUNTReturn {
820 #[allow(missing_docs)]
821 pub _0: alloy::sol_types::private::primitives::aliases::U256,
822 }
823 #[allow(
824 non_camel_case_types,
825 non_snake_case,
826 clippy::pub_underscore_fields,
827 clippy::style
828 )]
829 const _: () = {
830 use alloy::sol_types as alloy_sol_types;
831 {
832 #[doc(hidden)]
833 type UnderlyingSolTuple<'a> = ();
834 #[doc(hidden)]
835 type UnderlyingRustTuple<'a> = ();
836 #[cfg(test)]
837 #[allow(dead_code, unreachable_patterns)]
838 fn _type_assertion(
839 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
840 ) {
841 match _t {
842 alloy_sol_types::private::AssertTypeEq::<
843 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
844 >(_) => {}
845 }
846 }
847 #[automatically_derived]
848 #[doc(hidden)]
849 impl ::core::convert::From<MAX_REGISTRATION_PER_ACCOUNTCall>
850 for UnderlyingRustTuple<'_> {
851 fn from(value: MAX_REGISTRATION_PER_ACCOUNTCall) -> Self {
852 ()
853 }
854 }
855 #[automatically_derived]
856 #[doc(hidden)]
857 impl ::core::convert::From<UnderlyingRustTuple<'_>>
858 for MAX_REGISTRATION_PER_ACCOUNTCall {
859 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
860 Self
861 }
862 }
863 }
864 {
865 #[doc(hidden)]
866 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
867 #[doc(hidden)]
868 type UnderlyingRustTuple<'a> = (
869 alloy::sol_types::private::primitives::aliases::U256,
870 );
871 #[cfg(test)]
872 #[allow(dead_code, unreachable_patterns)]
873 fn _type_assertion(
874 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
875 ) {
876 match _t {
877 alloy_sol_types::private::AssertTypeEq::<
878 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
879 >(_) => {}
880 }
881 }
882 #[automatically_derived]
883 #[doc(hidden)]
884 impl ::core::convert::From<MAX_REGISTRATION_PER_ACCOUNTReturn>
885 for UnderlyingRustTuple<'_> {
886 fn from(value: MAX_REGISTRATION_PER_ACCOUNTReturn) -> Self {
887 (value._0,)
888 }
889 }
890 #[automatically_derived]
891 #[doc(hidden)]
892 impl ::core::convert::From<UnderlyingRustTuple<'_>>
893 for MAX_REGISTRATION_PER_ACCOUNTReturn {
894 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
895 Self { _0: tuple.0 }
896 }
897 }
898 }
899 #[automatically_derived]
900 impl alloy_sol_types::SolCall for MAX_REGISTRATION_PER_ACCOUNTCall {
901 type Parameters<'a> = ();
902 type Token<'a> = <Self::Parameters<
903 'a,
904 > as alloy_sol_types::SolType>::Token<'a>;
905 type Return = alloy::sol_types::private::primitives::aliases::U256;
906 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
907 type ReturnToken<'a> = <Self::ReturnTuple<
908 'a,
909 > as alloy_sol_types::SolType>::Token<'a>;
910 const SIGNATURE: &'static str = "MAX_REGISTRATION_PER_ACCOUNT()";
911 const SELECTOR: [u8; 4] = [244u8, 108u8, 132u8, 184u8];
912 #[inline]
913 fn new<'a>(
914 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
915 ) -> Self {
916 tuple.into()
917 }
918 #[inline]
919 fn tokenize(&self) -> Self::Token<'_> {
920 ()
921 }
922 #[inline]
923 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
924 (
925 <alloy::sol_types::sol_data::Uint<
926 256,
927 > as alloy_sol_types::SolType>::tokenize(ret),
928 )
929 }
930 #[inline]
931 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
932 <Self::ReturnTuple<
933 '_,
934 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
935 .map(|r| {
936 let r: MAX_REGISTRATION_PER_ACCOUNTReturn = r.into();
937 r._0
938 })
939 }
940 #[inline]
941 fn abi_decode_returns_validate(
942 data: &[u8],
943 ) -> alloy_sol_types::Result<Self::Return> {
944 <Self::ReturnTuple<
945 '_,
946 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
947 .map(|r| {
948 let r: MAX_REGISTRATION_PER_ACCOUNTReturn = r.into();
949 r._0
950 })
951 }
952 }
953 };
954 #[derive(serde::Serialize, serde::Deserialize)]
955 #[derive(Default, Debug, PartialEq, Eq, Hash)]
956 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
961 #[derive(Clone)]
962 pub struct canOperateForCall {
963 #[allow(missing_docs)]
964 pub _0: alloy::sol_types::private::Address,
965 #[allow(missing_docs)]
966 pub _1: alloy::sol_types::private::Address,
967 }
968 #[derive(serde::Serialize, serde::Deserialize)]
969 #[derive(Default, Debug, PartialEq, Eq, Hash)]
970 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
972 #[derive(Clone)]
973 pub struct canOperateForReturn {
974 #[allow(missing_docs)]
975 pub eligiblity: bool,
976 }
977 #[allow(
978 non_camel_case_types,
979 non_snake_case,
980 clippy::pub_underscore_fields,
981 clippy::style
982 )]
983 const _: () = {
984 use alloy::sol_types as alloy_sol_types;
985 {
986 #[doc(hidden)]
987 type UnderlyingSolTuple<'a> = (
988 alloy::sol_types::sol_data::Address,
989 alloy::sol_types::sol_data::Address,
990 );
991 #[doc(hidden)]
992 type UnderlyingRustTuple<'a> = (
993 alloy::sol_types::private::Address,
994 alloy::sol_types::private::Address,
995 );
996 #[cfg(test)]
997 #[allow(dead_code, unreachable_patterns)]
998 fn _type_assertion(
999 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1000 ) {
1001 match _t {
1002 alloy_sol_types::private::AssertTypeEq::<
1003 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1004 >(_) => {}
1005 }
1006 }
1007 #[automatically_derived]
1008 #[doc(hidden)]
1009 impl ::core::convert::From<canOperateForCall> for UnderlyingRustTuple<'_> {
1010 fn from(value: canOperateForCall) -> Self {
1011 (value._0, value._1)
1012 }
1013 }
1014 #[automatically_derived]
1015 #[doc(hidden)]
1016 impl ::core::convert::From<UnderlyingRustTuple<'_>> for canOperateForCall {
1017 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1018 Self { _0: tuple.0, _1: tuple.1 }
1019 }
1020 }
1021 }
1022 {
1023 #[doc(hidden)]
1024 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1025 #[doc(hidden)]
1026 type UnderlyingRustTuple<'a> = (bool,);
1027 #[cfg(test)]
1028 #[allow(dead_code, unreachable_patterns)]
1029 fn _type_assertion(
1030 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1031 ) {
1032 match _t {
1033 alloy_sol_types::private::AssertTypeEq::<
1034 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1035 >(_) => {}
1036 }
1037 }
1038 #[automatically_derived]
1039 #[doc(hidden)]
1040 impl ::core::convert::From<canOperateForReturn> for UnderlyingRustTuple<'_> {
1041 fn from(value: canOperateForReturn) -> Self {
1042 (value.eligiblity,)
1043 }
1044 }
1045 #[automatically_derived]
1046 #[doc(hidden)]
1047 impl ::core::convert::From<UnderlyingRustTuple<'_>> for canOperateForReturn {
1048 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1049 Self { eligiblity: tuple.0 }
1050 }
1051 }
1052 }
1053 #[automatically_derived]
1054 impl alloy_sol_types::SolCall for canOperateForCall {
1055 type Parameters<'a> = (
1056 alloy::sol_types::sol_data::Address,
1057 alloy::sol_types::sol_data::Address,
1058 );
1059 type Token<'a> = <Self::Parameters<
1060 'a,
1061 > as alloy_sol_types::SolType>::Token<'a>;
1062 type Return = bool;
1063 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1064 type ReturnToken<'a> = <Self::ReturnTuple<
1065 'a,
1066 > as alloy_sol_types::SolType>::Token<'a>;
1067 const SIGNATURE: &'static str = "canOperateFor(address,address)";
1068 const SELECTOR: [u8; 4] = [216u8, 90u8, 208u8, 68u8];
1069 #[inline]
1070 fn new<'a>(
1071 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1072 ) -> Self {
1073 tuple.into()
1074 }
1075 #[inline]
1076 fn tokenize(&self) -> Self::Token<'_> {
1077 (
1078 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1079 &self._0,
1080 ),
1081 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1082 &self._1,
1083 ),
1084 )
1085 }
1086 #[inline]
1087 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1088 (
1089 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
1090 ret,
1091 ),
1092 )
1093 }
1094 #[inline]
1095 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1096 <Self::ReturnTuple<
1097 '_,
1098 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1099 .map(|r| {
1100 let r: canOperateForReturn = r.into();
1101 r.eligiblity
1102 })
1103 }
1104 #[inline]
1105 fn abi_decode_returns_validate(
1106 data: &[u8],
1107 ) -> alloy_sol_types::Result<Self::Return> {
1108 <Self::ReturnTuple<
1109 '_,
1110 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1111 .map(|r| {
1112 let r: canOperateForReturn = r.into();
1113 r.eligiblity
1114 })
1115 }
1116 }
1117 };
1118 #[derive(serde::Serialize, serde::Deserialize)]
1119 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1120 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1125 #[derive(Clone)]
1126 pub struct isAllAllowedCall;
1127 #[derive(serde::Serialize, serde::Deserialize)]
1128 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1129 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1131 #[derive(Clone)]
1132 pub struct isAllAllowedReturn {
1133 #[allow(missing_docs)]
1134 pub _0: bool,
1135 }
1136 #[allow(
1137 non_camel_case_types,
1138 non_snake_case,
1139 clippy::pub_underscore_fields,
1140 clippy::style
1141 )]
1142 const _: () = {
1143 use alloy::sol_types as alloy_sol_types;
1144 {
1145 #[doc(hidden)]
1146 type UnderlyingSolTuple<'a> = ();
1147 #[doc(hidden)]
1148 type UnderlyingRustTuple<'a> = ();
1149 #[cfg(test)]
1150 #[allow(dead_code, unreachable_patterns)]
1151 fn _type_assertion(
1152 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1153 ) {
1154 match _t {
1155 alloy_sol_types::private::AssertTypeEq::<
1156 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1157 >(_) => {}
1158 }
1159 }
1160 #[automatically_derived]
1161 #[doc(hidden)]
1162 impl ::core::convert::From<isAllAllowedCall> for UnderlyingRustTuple<'_> {
1163 fn from(value: isAllAllowedCall) -> Self {
1164 ()
1165 }
1166 }
1167 #[automatically_derived]
1168 #[doc(hidden)]
1169 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isAllAllowedCall {
1170 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1171 Self
1172 }
1173 }
1174 }
1175 {
1176 #[doc(hidden)]
1177 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1178 #[doc(hidden)]
1179 type UnderlyingRustTuple<'a> = (bool,);
1180 #[cfg(test)]
1181 #[allow(dead_code, unreachable_patterns)]
1182 fn _type_assertion(
1183 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1184 ) {
1185 match _t {
1186 alloy_sol_types::private::AssertTypeEq::<
1187 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1188 >(_) => {}
1189 }
1190 }
1191 #[automatically_derived]
1192 #[doc(hidden)]
1193 impl ::core::convert::From<isAllAllowedReturn> for UnderlyingRustTuple<'_> {
1194 fn from(value: isAllAllowedReturn) -> Self {
1195 (value._0,)
1196 }
1197 }
1198 #[automatically_derived]
1199 #[doc(hidden)]
1200 impl ::core::convert::From<UnderlyingRustTuple<'_>> for isAllAllowedReturn {
1201 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1202 Self { _0: tuple.0 }
1203 }
1204 }
1205 }
1206 #[automatically_derived]
1207 impl alloy_sol_types::SolCall for isAllAllowedCall {
1208 type Parameters<'a> = ();
1209 type Token<'a> = <Self::Parameters<
1210 'a,
1211 > as alloy_sol_types::SolType>::Token<'a>;
1212 type Return = bool;
1213 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
1214 type ReturnToken<'a> = <Self::ReturnTuple<
1215 'a,
1216 > as alloy_sol_types::SolType>::Token<'a>;
1217 const SIGNATURE: &'static str = "isAllAllowed()";
1218 const SELECTOR: [u8; 4] = [246u8, 127u8, 94u8, 111u8];
1219 #[inline]
1220 fn new<'a>(
1221 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1222 ) -> Self {
1223 tuple.into()
1224 }
1225 #[inline]
1226 fn tokenize(&self) -> Self::Token<'_> {
1227 ()
1228 }
1229 #[inline]
1230 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1231 (
1232 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
1233 ret,
1234 ),
1235 )
1236 }
1237 #[inline]
1238 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1239 <Self::ReturnTuple<
1240 '_,
1241 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1242 .map(|r| {
1243 let r: isAllAllowedReturn = r.into();
1244 r._0
1245 })
1246 }
1247 #[inline]
1248 fn abi_decode_returns_validate(
1249 data: &[u8],
1250 ) -> alloy_sol_types::Result<Self::Return> {
1251 <Self::ReturnTuple<
1252 '_,
1253 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1254 .map(|r| {
1255 let r: isAllAllowedReturn = r.into();
1256 r._0
1257 })
1258 }
1259 }
1260 };
1261 #[derive(serde::Serialize, serde::Deserialize)]
1262 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1263 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1268 #[derive(Clone)]
1269 pub struct maxAllowedRegistrationsCall {
1270 #[allow(missing_docs)]
1271 pub account: alloy::sol_types::private::Address,
1272 }
1273 #[derive(serde::Serialize, serde::Deserialize)]
1274 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1275 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1277 #[derive(Clone)]
1278 pub struct maxAllowedRegistrationsReturn {
1279 #[allow(missing_docs)]
1280 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1281 }
1282 #[allow(
1283 non_camel_case_types,
1284 non_snake_case,
1285 clippy::pub_underscore_fields,
1286 clippy::style
1287 )]
1288 const _: () = {
1289 use alloy::sol_types as alloy_sol_types;
1290 {
1291 #[doc(hidden)]
1292 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1293 #[doc(hidden)]
1294 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1295 #[cfg(test)]
1296 #[allow(dead_code, unreachable_patterns)]
1297 fn _type_assertion(
1298 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1299 ) {
1300 match _t {
1301 alloy_sol_types::private::AssertTypeEq::<
1302 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1303 >(_) => {}
1304 }
1305 }
1306 #[automatically_derived]
1307 #[doc(hidden)]
1308 impl ::core::convert::From<maxAllowedRegistrationsCall>
1309 for UnderlyingRustTuple<'_> {
1310 fn from(value: maxAllowedRegistrationsCall) -> Self {
1311 (value.account,)
1312 }
1313 }
1314 #[automatically_derived]
1315 #[doc(hidden)]
1316 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1317 for maxAllowedRegistrationsCall {
1318 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1319 Self { account: tuple.0 }
1320 }
1321 }
1322 }
1323 {
1324 #[doc(hidden)]
1325 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1326 #[doc(hidden)]
1327 type UnderlyingRustTuple<'a> = (
1328 alloy::sol_types::private::primitives::aliases::U256,
1329 );
1330 #[cfg(test)]
1331 #[allow(dead_code, unreachable_patterns)]
1332 fn _type_assertion(
1333 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1334 ) {
1335 match _t {
1336 alloy_sol_types::private::AssertTypeEq::<
1337 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1338 >(_) => {}
1339 }
1340 }
1341 #[automatically_derived]
1342 #[doc(hidden)]
1343 impl ::core::convert::From<maxAllowedRegistrationsReturn>
1344 for UnderlyingRustTuple<'_> {
1345 fn from(value: maxAllowedRegistrationsReturn) -> Self {
1346 (value._0,)
1347 }
1348 }
1349 #[automatically_derived]
1350 #[doc(hidden)]
1351 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1352 for maxAllowedRegistrationsReturn {
1353 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1354 Self { _0: tuple.0 }
1355 }
1356 }
1357 }
1358 #[automatically_derived]
1359 impl alloy_sol_types::SolCall for maxAllowedRegistrationsCall {
1360 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1361 type Token<'a> = <Self::Parameters<
1362 'a,
1363 > as alloy_sol_types::SolType>::Token<'a>;
1364 type Return = alloy::sol_types::private::primitives::aliases::U256;
1365 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1366 type ReturnToken<'a> = <Self::ReturnTuple<
1367 'a,
1368 > as alloy_sol_types::SolType>::Token<'a>;
1369 const SIGNATURE: &'static str = "maxAllowedRegistrations(address)";
1370 const SELECTOR: [u8; 4] = [179u8, 84u8, 78u8, 130u8];
1371 #[inline]
1372 fn new<'a>(
1373 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1374 ) -> Self {
1375 tuple.into()
1376 }
1377 #[inline]
1378 fn tokenize(&self) -> Self::Token<'_> {
1379 (
1380 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1381 &self.account,
1382 ),
1383 )
1384 }
1385 #[inline]
1386 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1387 (
1388 <alloy::sol_types::sol_data::Uint<
1389 256,
1390 > as alloy_sol_types::SolType>::tokenize(ret),
1391 )
1392 }
1393 #[inline]
1394 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1395 <Self::ReturnTuple<
1396 '_,
1397 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1398 .map(|r| {
1399 let r: maxAllowedRegistrationsReturn = r.into();
1400 r._0
1401 })
1402 }
1403 #[inline]
1404 fn abi_decode_returns_validate(
1405 data: &[u8],
1406 ) -> alloy_sol_types::Result<Self::Return> {
1407 <Self::ReturnTuple<
1408 '_,
1409 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1410 .map(|r| {
1411 let r: maxAllowedRegistrationsReturn = r.into();
1412 r._0
1413 })
1414 }
1415 }
1416 };
1417 #[derive(serde::Serialize, serde::Deserialize)]
1418 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1419 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1424 #[derive(Clone)]
1425 pub struct ownerCall;
1426 #[derive(serde::Serialize, serde::Deserialize)]
1427 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1428 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1430 #[derive(Clone)]
1431 pub struct ownerReturn {
1432 #[allow(missing_docs)]
1433 pub _0: alloy::sol_types::private::Address,
1434 }
1435 #[allow(
1436 non_camel_case_types,
1437 non_snake_case,
1438 clippy::pub_underscore_fields,
1439 clippy::style
1440 )]
1441 const _: () = {
1442 use alloy::sol_types as alloy_sol_types;
1443 {
1444 #[doc(hidden)]
1445 type UnderlyingSolTuple<'a> = ();
1446 #[doc(hidden)]
1447 type UnderlyingRustTuple<'a> = ();
1448 #[cfg(test)]
1449 #[allow(dead_code, unreachable_patterns)]
1450 fn _type_assertion(
1451 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1452 ) {
1453 match _t {
1454 alloy_sol_types::private::AssertTypeEq::<
1455 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1456 >(_) => {}
1457 }
1458 }
1459 #[automatically_derived]
1460 #[doc(hidden)]
1461 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
1462 fn from(value: ownerCall) -> Self {
1463 ()
1464 }
1465 }
1466 #[automatically_derived]
1467 #[doc(hidden)]
1468 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
1469 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1470 Self
1471 }
1472 }
1473 }
1474 {
1475 #[doc(hidden)]
1476 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1477 #[doc(hidden)]
1478 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1479 #[cfg(test)]
1480 #[allow(dead_code, unreachable_patterns)]
1481 fn _type_assertion(
1482 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1483 ) {
1484 match _t {
1485 alloy_sol_types::private::AssertTypeEq::<
1486 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1487 >(_) => {}
1488 }
1489 }
1490 #[automatically_derived]
1491 #[doc(hidden)]
1492 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
1493 fn from(value: ownerReturn) -> Self {
1494 (value._0,)
1495 }
1496 }
1497 #[automatically_derived]
1498 #[doc(hidden)]
1499 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
1500 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1501 Self { _0: tuple.0 }
1502 }
1503 }
1504 }
1505 #[automatically_derived]
1506 impl alloy_sol_types::SolCall for ownerCall {
1507 type Parameters<'a> = ();
1508 type Token<'a> = <Self::Parameters<
1509 'a,
1510 > as alloy_sol_types::SolType>::Token<'a>;
1511 type Return = alloy::sol_types::private::Address;
1512 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1513 type ReturnToken<'a> = <Self::ReturnTuple<
1514 'a,
1515 > as alloy_sol_types::SolType>::Token<'a>;
1516 const SIGNATURE: &'static str = "owner()";
1517 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
1518 #[inline]
1519 fn new<'a>(
1520 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1521 ) -> Self {
1522 tuple.into()
1523 }
1524 #[inline]
1525 fn tokenize(&self) -> Self::Token<'_> {
1526 ()
1527 }
1528 #[inline]
1529 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1530 (
1531 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1532 ret,
1533 ),
1534 )
1535 }
1536 #[inline]
1537 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1538 <Self::ReturnTuple<
1539 '_,
1540 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1541 .map(|r| {
1542 let r: ownerReturn = r.into();
1543 r._0
1544 })
1545 }
1546 #[inline]
1547 fn abi_decode_returns_validate(
1548 data: &[u8],
1549 ) -> alloy_sol_types::Result<Self::Return> {
1550 <Self::ReturnTuple<
1551 '_,
1552 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1553 .map(|r| {
1554 let r: ownerReturn = r.into();
1555 r._0
1556 })
1557 }
1558 }
1559 };
1560 #[derive(serde::Serialize, serde::Deserialize)]
1561 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1562 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1567 #[derive(Clone)]
1568 pub struct ownerAddAccountCall {
1569 #[allow(missing_docs)]
1570 pub account: alloy::sol_types::private::Address,
1571 }
1572 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1574 #[derive(Clone)]
1575 pub struct ownerAddAccountReturn {}
1576 #[allow(
1577 non_camel_case_types,
1578 non_snake_case,
1579 clippy::pub_underscore_fields,
1580 clippy::style
1581 )]
1582 const _: () = {
1583 use alloy::sol_types as alloy_sol_types;
1584 {
1585 #[doc(hidden)]
1586 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1587 #[doc(hidden)]
1588 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1589 #[cfg(test)]
1590 #[allow(dead_code, unreachable_patterns)]
1591 fn _type_assertion(
1592 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1593 ) {
1594 match _t {
1595 alloy_sol_types::private::AssertTypeEq::<
1596 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1597 >(_) => {}
1598 }
1599 }
1600 #[automatically_derived]
1601 #[doc(hidden)]
1602 impl ::core::convert::From<ownerAddAccountCall> for UnderlyingRustTuple<'_> {
1603 fn from(value: ownerAddAccountCall) -> Self {
1604 (value.account,)
1605 }
1606 }
1607 #[automatically_derived]
1608 #[doc(hidden)]
1609 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerAddAccountCall {
1610 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1611 Self { account: tuple.0 }
1612 }
1613 }
1614 }
1615 {
1616 #[doc(hidden)]
1617 type UnderlyingSolTuple<'a> = ();
1618 #[doc(hidden)]
1619 type UnderlyingRustTuple<'a> = ();
1620 #[cfg(test)]
1621 #[allow(dead_code, unreachable_patterns)]
1622 fn _type_assertion(
1623 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1624 ) {
1625 match _t {
1626 alloy_sol_types::private::AssertTypeEq::<
1627 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1628 >(_) => {}
1629 }
1630 }
1631 #[automatically_derived]
1632 #[doc(hidden)]
1633 impl ::core::convert::From<ownerAddAccountReturn>
1634 for UnderlyingRustTuple<'_> {
1635 fn from(value: ownerAddAccountReturn) -> Self {
1636 ()
1637 }
1638 }
1639 #[automatically_derived]
1640 #[doc(hidden)]
1641 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1642 for ownerAddAccountReturn {
1643 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1644 Self {}
1645 }
1646 }
1647 }
1648 impl ownerAddAccountReturn {
1649 fn _tokenize(
1650 &self,
1651 ) -> <ownerAddAccountCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1652 ()
1653 }
1654 }
1655 #[automatically_derived]
1656 impl alloy_sol_types::SolCall for ownerAddAccountCall {
1657 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1658 type Token<'a> = <Self::Parameters<
1659 'a,
1660 > as alloy_sol_types::SolType>::Token<'a>;
1661 type Return = ownerAddAccountReturn;
1662 type ReturnTuple<'a> = ();
1663 type ReturnToken<'a> = <Self::ReturnTuple<
1664 'a,
1665 > as alloy_sol_types::SolType>::Token<'a>;
1666 const SIGNATURE: &'static str = "ownerAddAccount(address)";
1667 const SELECTOR: [u8; 4] = [167u8, 27u8, 27u8, 116u8];
1668 #[inline]
1669 fn new<'a>(
1670 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1671 ) -> Self {
1672 tuple.into()
1673 }
1674 #[inline]
1675 fn tokenize(&self) -> Self::Token<'_> {
1676 (
1677 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1678 &self.account,
1679 ),
1680 )
1681 }
1682 #[inline]
1683 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1684 ownerAddAccountReturn::_tokenize(ret)
1685 }
1686 #[inline]
1687 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1688 <Self::ReturnTuple<
1689 '_,
1690 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1691 .map(Into::into)
1692 }
1693 #[inline]
1694 fn abi_decode_returns_validate(
1695 data: &[u8],
1696 ) -> alloy_sol_types::Result<Self::Return> {
1697 <Self::ReturnTuple<
1698 '_,
1699 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1700 .map(Into::into)
1701 }
1702 }
1703 };
1704 #[derive(serde::Serialize, serde::Deserialize)]
1705 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1706 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1711 #[derive(Clone)]
1712 pub struct ownerBatchAddAccountsCall {
1713 #[allow(missing_docs)]
1714 pub accounts: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1715 }
1716 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1718 #[derive(Clone)]
1719 pub struct ownerBatchAddAccountsReturn {}
1720 #[allow(
1721 non_camel_case_types,
1722 non_snake_case,
1723 clippy::pub_underscore_fields,
1724 clippy::style
1725 )]
1726 const _: () = {
1727 use alloy::sol_types as alloy_sol_types;
1728 {
1729 #[doc(hidden)]
1730 type UnderlyingSolTuple<'a> = (
1731 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
1732 );
1733 #[doc(hidden)]
1734 type UnderlyingRustTuple<'a> = (
1735 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1736 );
1737 #[cfg(test)]
1738 #[allow(dead_code, unreachable_patterns)]
1739 fn _type_assertion(
1740 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1741 ) {
1742 match _t {
1743 alloy_sol_types::private::AssertTypeEq::<
1744 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1745 >(_) => {}
1746 }
1747 }
1748 #[automatically_derived]
1749 #[doc(hidden)]
1750 impl ::core::convert::From<ownerBatchAddAccountsCall>
1751 for UnderlyingRustTuple<'_> {
1752 fn from(value: ownerBatchAddAccountsCall) -> Self {
1753 (value.accounts,)
1754 }
1755 }
1756 #[automatically_derived]
1757 #[doc(hidden)]
1758 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1759 for ownerBatchAddAccountsCall {
1760 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1761 Self { accounts: tuple.0 }
1762 }
1763 }
1764 }
1765 {
1766 #[doc(hidden)]
1767 type UnderlyingSolTuple<'a> = ();
1768 #[doc(hidden)]
1769 type UnderlyingRustTuple<'a> = ();
1770 #[cfg(test)]
1771 #[allow(dead_code, unreachable_patterns)]
1772 fn _type_assertion(
1773 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1774 ) {
1775 match _t {
1776 alloy_sol_types::private::AssertTypeEq::<
1777 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1778 >(_) => {}
1779 }
1780 }
1781 #[automatically_derived]
1782 #[doc(hidden)]
1783 impl ::core::convert::From<ownerBatchAddAccountsReturn>
1784 for UnderlyingRustTuple<'_> {
1785 fn from(value: ownerBatchAddAccountsReturn) -> Self {
1786 ()
1787 }
1788 }
1789 #[automatically_derived]
1790 #[doc(hidden)]
1791 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1792 for ownerBatchAddAccountsReturn {
1793 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1794 Self {}
1795 }
1796 }
1797 }
1798 impl ownerBatchAddAccountsReturn {
1799 fn _tokenize(
1800 &self,
1801 ) -> <ownerBatchAddAccountsCall as alloy_sol_types::SolCall>::ReturnToken<
1802 '_,
1803 > {
1804 ()
1805 }
1806 }
1807 #[automatically_derived]
1808 impl alloy_sol_types::SolCall for ownerBatchAddAccountsCall {
1809 type Parameters<'a> = (
1810 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
1811 );
1812 type Token<'a> = <Self::Parameters<
1813 'a,
1814 > as alloy_sol_types::SolType>::Token<'a>;
1815 type Return = ownerBatchAddAccountsReturn;
1816 type ReturnTuple<'a> = ();
1817 type ReturnToken<'a> = <Self::ReturnTuple<
1818 'a,
1819 > as alloy_sol_types::SolType>::Token<'a>;
1820 const SIGNATURE: &'static str = "ownerBatchAddAccounts(address[])";
1821 const SELECTOR: [u8; 4] = [72u8, 99u8, 84u8, 226u8];
1822 #[inline]
1823 fn new<'a>(
1824 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1825 ) -> Self {
1826 tuple.into()
1827 }
1828 #[inline]
1829 fn tokenize(&self) -> Self::Token<'_> {
1830 (
1831 <alloy::sol_types::sol_data::Array<
1832 alloy::sol_types::sol_data::Address,
1833 > as alloy_sol_types::SolType>::tokenize(&self.accounts),
1834 )
1835 }
1836 #[inline]
1837 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1838 ownerBatchAddAccountsReturn::_tokenize(ret)
1839 }
1840 #[inline]
1841 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1842 <Self::ReturnTuple<
1843 '_,
1844 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1845 .map(Into::into)
1846 }
1847 #[inline]
1848 fn abi_decode_returns_validate(
1849 data: &[u8],
1850 ) -> alloy_sol_types::Result<Self::Return> {
1851 <Self::ReturnTuple<
1852 '_,
1853 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1854 .map(Into::into)
1855 }
1856 }
1857 };
1858 #[derive(serde::Serialize, serde::Deserialize)]
1859 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1860 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1865 #[derive(Clone)]
1866 pub struct ownerBatchRemoveAccountsCall {
1867 #[allow(missing_docs)]
1868 pub accounts: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1869 }
1870 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1872 #[derive(Clone)]
1873 pub struct ownerBatchRemoveAccountsReturn {}
1874 #[allow(
1875 non_camel_case_types,
1876 non_snake_case,
1877 clippy::pub_underscore_fields,
1878 clippy::style
1879 )]
1880 const _: () = {
1881 use alloy::sol_types as alloy_sol_types;
1882 {
1883 #[doc(hidden)]
1884 type UnderlyingSolTuple<'a> = (
1885 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
1886 );
1887 #[doc(hidden)]
1888 type UnderlyingRustTuple<'a> = (
1889 alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
1890 );
1891 #[cfg(test)]
1892 #[allow(dead_code, unreachable_patterns)]
1893 fn _type_assertion(
1894 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1895 ) {
1896 match _t {
1897 alloy_sol_types::private::AssertTypeEq::<
1898 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1899 >(_) => {}
1900 }
1901 }
1902 #[automatically_derived]
1903 #[doc(hidden)]
1904 impl ::core::convert::From<ownerBatchRemoveAccountsCall>
1905 for UnderlyingRustTuple<'_> {
1906 fn from(value: ownerBatchRemoveAccountsCall) -> Self {
1907 (value.accounts,)
1908 }
1909 }
1910 #[automatically_derived]
1911 #[doc(hidden)]
1912 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1913 for ownerBatchRemoveAccountsCall {
1914 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1915 Self { accounts: tuple.0 }
1916 }
1917 }
1918 }
1919 {
1920 #[doc(hidden)]
1921 type UnderlyingSolTuple<'a> = ();
1922 #[doc(hidden)]
1923 type UnderlyingRustTuple<'a> = ();
1924 #[cfg(test)]
1925 #[allow(dead_code, unreachable_patterns)]
1926 fn _type_assertion(
1927 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1928 ) {
1929 match _t {
1930 alloy_sol_types::private::AssertTypeEq::<
1931 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1932 >(_) => {}
1933 }
1934 }
1935 #[automatically_derived]
1936 #[doc(hidden)]
1937 impl ::core::convert::From<ownerBatchRemoveAccountsReturn>
1938 for UnderlyingRustTuple<'_> {
1939 fn from(value: ownerBatchRemoveAccountsReturn) -> Self {
1940 ()
1941 }
1942 }
1943 #[automatically_derived]
1944 #[doc(hidden)]
1945 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1946 for ownerBatchRemoveAccountsReturn {
1947 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1948 Self {}
1949 }
1950 }
1951 }
1952 impl ownerBatchRemoveAccountsReturn {
1953 fn _tokenize(
1954 &self,
1955 ) -> <ownerBatchRemoveAccountsCall as alloy_sol_types::SolCall>::ReturnToken<
1956 '_,
1957 > {
1958 ()
1959 }
1960 }
1961 #[automatically_derived]
1962 impl alloy_sol_types::SolCall for ownerBatchRemoveAccountsCall {
1963 type Parameters<'a> = (
1964 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::Address>,
1965 );
1966 type Token<'a> = <Self::Parameters<
1967 'a,
1968 > as alloy_sol_types::SolType>::Token<'a>;
1969 type Return = ownerBatchRemoveAccountsReturn;
1970 type ReturnTuple<'a> = ();
1971 type ReturnToken<'a> = <Self::ReturnTuple<
1972 'a,
1973 > as alloy_sol_types::SolType>::Token<'a>;
1974 const SIGNATURE: &'static str = "ownerBatchRemoveAccounts(address[])";
1975 const SELECTOR: [u8; 4] = [92u8, 84u8, 113u8, 231u8];
1976 #[inline]
1977 fn new<'a>(
1978 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1979 ) -> Self {
1980 tuple.into()
1981 }
1982 #[inline]
1983 fn tokenize(&self) -> Self::Token<'_> {
1984 (
1985 <alloy::sol_types::sol_data::Array<
1986 alloy::sol_types::sol_data::Address,
1987 > as alloy_sol_types::SolType>::tokenize(&self.accounts),
1988 )
1989 }
1990 #[inline]
1991 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1992 ownerBatchRemoveAccountsReturn::_tokenize(ret)
1993 }
1994 #[inline]
1995 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1996 <Self::ReturnTuple<
1997 '_,
1998 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1999 .map(Into::into)
2000 }
2001 #[inline]
2002 fn abi_decode_returns_validate(
2003 data: &[u8],
2004 ) -> alloy_sol_types::Result<Self::Return> {
2005 <Self::ReturnTuple<
2006 '_,
2007 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2008 .map(Into::into)
2009 }
2010 }
2011 };
2012 #[derive(serde::Serialize, serde::Deserialize)]
2013 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2014 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2019 #[derive(Clone)]
2020 pub struct ownerRemoveAccountCall {
2021 #[allow(missing_docs)]
2022 pub account: alloy::sol_types::private::Address,
2023 }
2024 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2026 #[derive(Clone)]
2027 pub struct ownerRemoveAccountReturn {}
2028 #[allow(
2029 non_camel_case_types,
2030 non_snake_case,
2031 clippy::pub_underscore_fields,
2032 clippy::style
2033 )]
2034 const _: () = {
2035 use alloy::sol_types as alloy_sol_types;
2036 {
2037 #[doc(hidden)]
2038 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2039 #[doc(hidden)]
2040 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2041 #[cfg(test)]
2042 #[allow(dead_code, unreachable_patterns)]
2043 fn _type_assertion(
2044 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2045 ) {
2046 match _t {
2047 alloy_sol_types::private::AssertTypeEq::<
2048 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2049 >(_) => {}
2050 }
2051 }
2052 #[automatically_derived]
2053 #[doc(hidden)]
2054 impl ::core::convert::From<ownerRemoveAccountCall>
2055 for UnderlyingRustTuple<'_> {
2056 fn from(value: ownerRemoveAccountCall) -> Self {
2057 (value.account,)
2058 }
2059 }
2060 #[automatically_derived]
2061 #[doc(hidden)]
2062 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2063 for ownerRemoveAccountCall {
2064 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2065 Self { account: tuple.0 }
2066 }
2067 }
2068 }
2069 {
2070 #[doc(hidden)]
2071 type UnderlyingSolTuple<'a> = ();
2072 #[doc(hidden)]
2073 type UnderlyingRustTuple<'a> = ();
2074 #[cfg(test)]
2075 #[allow(dead_code, unreachable_patterns)]
2076 fn _type_assertion(
2077 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2078 ) {
2079 match _t {
2080 alloy_sol_types::private::AssertTypeEq::<
2081 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2082 >(_) => {}
2083 }
2084 }
2085 #[automatically_derived]
2086 #[doc(hidden)]
2087 impl ::core::convert::From<ownerRemoveAccountReturn>
2088 for UnderlyingRustTuple<'_> {
2089 fn from(value: ownerRemoveAccountReturn) -> Self {
2090 ()
2091 }
2092 }
2093 #[automatically_derived]
2094 #[doc(hidden)]
2095 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2096 for ownerRemoveAccountReturn {
2097 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2098 Self {}
2099 }
2100 }
2101 }
2102 impl ownerRemoveAccountReturn {
2103 fn _tokenize(
2104 &self,
2105 ) -> <ownerRemoveAccountCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2106 ()
2107 }
2108 }
2109 #[automatically_derived]
2110 impl alloy_sol_types::SolCall for ownerRemoveAccountCall {
2111 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2112 type Token<'a> = <Self::Parameters<
2113 'a,
2114 > as alloy_sol_types::SolType>::Token<'a>;
2115 type Return = ownerRemoveAccountReturn;
2116 type ReturnTuple<'a> = ();
2117 type ReturnToken<'a> = <Self::ReturnTuple<
2118 'a,
2119 > as alloy_sol_types::SolType>::Token<'a>;
2120 const SIGNATURE: &'static str = "ownerRemoveAccount(address)";
2121 const SELECTOR: [u8; 4] = [64u8, 81u8, 242u8, 87u8];
2122 #[inline]
2123 fn new<'a>(
2124 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2125 ) -> Self {
2126 tuple.into()
2127 }
2128 #[inline]
2129 fn tokenize(&self) -> Self::Token<'_> {
2130 (
2131 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2132 &self.account,
2133 ),
2134 )
2135 }
2136 #[inline]
2137 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2138 ownerRemoveAccountReturn::_tokenize(ret)
2139 }
2140 #[inline]
2141 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2142 <Self::ReturnTuple<
2143 '_,
2144 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2145 .map(Into::into)
2146 }
2147 #[inline]
2148 fn abi_decode_returns_validate(
2149 data: &[u8],
2150 ) -> alloy_sol_types::Result<Self::Return> {
2151 <Self::ReturnTuple<
2152 '_,
2153 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2154 .map(Into::into)
2155 }
2156 }
2157 };
2158 #[derive(serde::Serialize, serde::Deserialize)]
2159 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2160 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2165 #[derive(Clone)]
2166 pub struct renounceOwnershipCall;
2167 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2169 #[derive(Clone)]
2170 pub struct renounceOwnershipReturn {}
2171 #[allow(
2172 non_camel_case_types,
2173 non_snake_case,
2174 clippy::pub_underscore_fields,
2175 clippy::style
2176 )]
2177 const _: () = {
2178 use alloy::sol_types as alloy_sol_types;
2179 {
2180 #[doc(hidden)]
2181 type UnderlyingSolTuple<'a> = ();
2182 #[doc(hidden)]
2183 type UnderlyingRustTuple<'a> = ();
2184 #[cfg(test)]
2185 #[allow(dead_code, unreachable_patterns)]
2186 fn _type_assertion(
2187 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2188 ) {
2189 match _t {
2190 alloy_sol_types::private::AssertTypeEq::<
2191 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2192 >(_) => {}
2193 }
2194 }
2195 #[automatically_derived]
2196 #[doc(hidden)]
2197 impl ::core::convert::From<renounceOwnershipCall>
2198 for UnderlyingRustTuple<'_> {
2199 fn from(value: renounceOwnershipCall) -> Self {
2200 ()
2201 }
2202 }
2203 #[automatically_derived]
2204 #[doc(hidden)]
2205 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2206 for renounceOwnershipCall {
2207 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2208 Self
2209 }
2210 }
2211 }
2212 {
2213 #[doc(hidden)]
2214 type UnderlyingSolTuple<'a> = ();
2215 #[doc(hidden)]
2216 type UnderlyingRustTuple<'a> = ();
2217 #[cfg(test)]
2218 #[allow(dead_code, unreachable_patterns)]
2219 fn _type_assertion(
2220 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2221 ) {
2222 match _t {
2223 alloy_sol_types::private::AssertTypeEq::<
2224 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2225 >(_) => {}
2226 }
2227 }
2228 #[automatically_derived]
2229 #[doc(hidden)]
2230 impl ::core::convert::From<renounceOwnershipReturn>
2231 for UnderlyingRustTuple<'_> {
2232 fn from(value: renounceOwnershipReturn) -> Self {
2233 ()
2234 }
2235 }
2236 #[automatically_derived]
2237 #[doc(hidden)]
2238 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2239 for renounceOwnershipReturn {
2240 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2241 Self {}
2242 }
2243 }
2244 }
2245 impl renounceOwnershipReturn {
2246 fn _tokenize(
2247 &self,
2248 ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2249 ()
2250 }
2251 }
2252 #[automatically_derived]
2253 impl alloy_sol_types::SolCall for renounceOwnershipCall {
2254 type Parameters<'a> = ();
2255 type Token<'a> = <Self::Parameters<
2256 'a,
2257 > as alloy_sol_types::SolType>::Token<'a>;
2258 type Return = renounceOwnershipReturn;
2259 type ReturnTuple<'a> = ();
2260 type ReturnToken<'a> = <Self::ReturnTuple<
2261 'a,
2262 > as alloy_sol_types::SolType>::Token<'a>;
2263 const SIGNATURE: &'static str = "renounceOwnership()";
2264 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
2265 #[inline]
2266 fn new<'a>(
2267 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2268 ) -> Self {
2269 tuple.into()
2270 }
2271 #[inline]
2272 fn tokenize(&self) -> Self::Token<'_> {
2273 ()
2274 }
2275 #[inline]
2276 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2277 renounceOwnershipReturn::_tokenize(ret)
2278 }
2279 #[inline]
2280 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2281 <Self::ReturnTuple<
2282 '_,
2283 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2284 .map(Into::into)
2285 }
2286 #[inline]
2287 fn abi_decode_returns_validate(
2288 data: &[u8],
2289 ) -> alloy_sol_types::Result<Self::Return> {
2290 <Self::ReturnTuple<
2291 '_,
2292 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2293 .map(Into::into)
2294 }
2295 }
2296 };
2297 #[derive(serde::Serialize, serde::Deserialize)]
2298 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2299 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2304 #[derive(Clone)]
2305 pub struct transferOwnershipCall {
2306 #[allow(missing_docs)]
2307 pub newOwner: alloy::sol_types::private::Address,
2308 }
2309 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2311 #[derive(Clone)]
2312 pub struct transferOwnershipReturn {}
2313 #[allow(
2314 non_camel_case_types,
2315 non_snake_case,
2316 clippy::pub_underscore_fields,
2317 clippy::style
2318 )]
2319 const _: () = {
2320 use alloy::sol_types as alloy_sol_types;
2321 {
2322 #[doc(hidden)]
2323 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2324 #[doc(hidden)]
2325 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2326 #[cfg(test)]
2327 #[allow(dead_code, unreachable_patterns)]
2328 fn _type_assertion(
2329 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2330 ) {
2331 match _t {
2332 alloy_sol_types::private::AssertTypeEq::<
2333 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2334 >(_) => {}
2335 }
2336 }
2337 #[automatically_derived]
2338 #[doc(hidden)]
2339 impl ::core::convert::From<transferOwnershipCall>
2340 for UnderlyingRustTuple<'_> {
2341 fn from(value: transferOwnershipCall) -> Self {
2342 (value.newOwner,)
2343 }
2344 }
2345 #[automatically_derived]
2346 #[doc(hidden)]
2347 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2348 for transferOwnershipCall {
2349 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2350 Self { newOwner: tuple.0 }
2351 }
2352 }
2353 }
2354 {
2355 #[doc(hidden)]
2356 type UnderlyingSolTuple<'a> = ();
2357 #[doc(hidden)]
2358 type UnderlyingRustTuple<'a> = ();
2359 #[cfg(test)]
2360 #[allow(dead_code, unreachable_patterns)]
2361 fn _type_assertion(
2362 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2363 ) {
2364 match _t {
2365 alloy_sol_types::private::AssertTypeEq::<
2366 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2367 >(_) => {}
2368 }
2369 }
2370 #[automatically_derived]
2371 #[doc(hidden)]
2372 impl ::core::convert::From<transferOwnershipReturn>
2373 for UnderlyingRustTuple<'_> {
2374 fn from(value: transferOwnershipReturn) -> Self {
2375 ()
2376 }
2377 }
2378 #[automatically_derived]
2379 #[doc(hidden)]
2380 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2381 for transferOwnershipReturn {
2382 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2383 Self {}
2384 }
2385 }
2386 }
2387 impl transferOwnershipReturn {
2388 fn _tokenize(
2389 &self,
2390 ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2391 ()
2392 }
2393 }
2394 #[automatically_derived]
2395 impl alloy_sol_types::SolCall for transferOwnershipCall {
2396 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2397 type Token<'a> = <Self::Parameters<
2398 'a,
2399 > as alloy_sol_types::SolType>::Token<'a>;
2400 type Return = transferOwnershipReturn;
2401 type ReturnTuple<'a> = ();
2402 type ReturnToken<'a> = <Self::ReturnTuple<
2403 'a,
2404 > as alloy_sol_types::SolType>::Token<'a>;
2405 const SIGNATURE: &'static str = "transferOwnership(address)";
2406 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
2407 #[inline]
2408 fn new<'a>(
2409 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2410 ) -> Self {
2411 tuple.into()
2412 }
2413 #[inline]
2414 fn tokenize(&self) -> Self::Token<'_> {
2415 (
2416 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2417 &self.newOwner,
2418 ),
2419 )
2420 }
2421 #[inline]
2422 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2423 transferOwnershipReturn::_tokenize(ret)
2424 }
2425 #[inline]
2426 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2427 <Self::ReturnTuple<
2428 '_,
2429 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2430 .map(Into::into)
2431 }
2432 #[inline]
2433 fn abi_decode_returns_validate(
2434 data: &[u8],
2435 ) -> alloy_sol_types::Result<Self::Return> {
2436 <Self::ReturnTuple<
2437 '_,
2438 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2439 .map(Into::into)
2440 }
2441 }
2442 };
2443 #[derive(serde::Serialize, serde::Deserialize)]
2444 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2445 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2450 #[derive(Clone)]
2451 pub struct updateAllowAllCall {
2452 #[allow(missing_docs)]
2453 pub _updatedAllow: bool,
2454 }
2455 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2457 #[derive(Clone)]
2458 pub struct updateAllowAllReturn {}
2459 #[allow(
2460 non_camel_case_types,
2461 non_snake_case,
2462 clippy::pub_underscore_fields,
2463 clippy::style
2464 )]
2465 const _: () = {
2466 use alloy::sol_types as alloy_sol_types;
2467 {
2468 #[doc(hidden)]
2469 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
2470 #[doc(hidden)]
2471 type UnderlyingRustTuple<'a> = (bool,);
2472 #[cfg(test)]
2473 #[allow(dead_code, unreachable_patterns)]
2474 fn _type_assertion(
2475 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2476 ) {
2477 match _t {
2478 alloy_sol_types::private::AssertTypeEq::<
2479 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2480 >(_) => {}
2481 }
2482 }
2483 #[automatically_derived]
2484 #[doc(hidden)]
2485 impl ::core::convert::From<updateAllowAllCall> for UnderlyingRustTuple<'_> {
2486 fn from(value: updateAllowAllCall) -> Self {
2487 (value._updatedAllow,)
2488 }
2489 }
2490 #[automatically_derived]
2491 #[doc(hidden)]
2492 impl ::core::convert::From<UnderlyingRustTuple<'_>> for updateAllowAllCall {
2493 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2494 Self { _updatedAllow: tuple.0 }
2495 }
2496 }
2497 }
2498 {
2499 #[doc(hidden)]
2500 type UnderlyingSolTuple<'a> = ();
2501 #[doc(hidden)]
2502 type UnderlyingRustTuple<'a> = ();
2503 #[cfg(test)]
2504 #[allow(dead_code, unreachable_patterns)]
2505 fn _type_assertion(
2506 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2507 ) {
2508 match _t {
2509 alloy_sol_types::private::AssertTypeEq::<
2510 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2511 >(_) => {}
2512 }
2513 }
2514 #[automatically_derived]
2515 #[doc(hidden)]
2516 impl ::core::convert::From<updateAllowAllReturn>
2517 for UnderlyingRustTuple<'_> {
2518 fn from(value: updateAllowAllReturn) -> Self {
2519 ()
2520 }
2521 }
2522 #[automatically_derived]
2523 #[doc(hidden)]
2524 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2525 for updateAllowAllReturn {
2526 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2527 Self {}
2528 }
2529 }
2530 }
2531 impl updateAllowAllReturn {
2532 fn _tokenize(
2533 &self,
2534 ) -> <updateAllowAllCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2535 ()
2536 }
2537 }
2538 #[automatically_derived]
2539 impl alloy_sol_types::SolCall for updateAllowAllCall {
2540 type Parameters<'a> = (alloy::sol_types::sol_data::Bool,);
2541 type Token<'a> = <Self::Parameters<
2542 'a,
2543 > as alloy_sol_types::SolType>::Token<'a>;
2544 type Return = updateAllowAllReturn;
2545 type ReturnTuple<'a> = ();
2546 type ReturnToken<'a> = <Self::ReturnTuple<
2547 'a,
2548 > as alloy_sol_types::SolType>::Token<'a>;
2549 const SIGNATURE: &'static str = "updateAllowAll(bool)";
2550 const SELECTOR: [u8; 4] = [8u8, 159u8, 250u8, 71u8];
2551 #[inline]
2552 fn new<'a>(
2553 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2554 ) -> Self {
2555 tuple.into()
2556 }
2557 #[inline]
2558 fn tokenize(&self) -> Self::Token<'_> {
2559 (
2560 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
2561 &self._updatedAllow,
2562 ),
2563 )
2564 }
2565 #[inline]
2566 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2567 updateAllowAllReturn::_tokenize(ret)
2568 }
2569 #[inline]
2570 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2571 <Self::ReturnTuple<
2572 '_,
2573 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2574 .map(Into::into)
2575 }
2576 #[inline]
2577 fn abi_decode_returns_validate(
2578 data: &[u8],
2579 ) -> alloy_sol_types::Result<Self::Return> {
2580 <Self::ReturnTuple<
2581 '_,
2582 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2583 .map(Into::into)
2584 }
2585 }
2586 };
2587 #[derive(serde::Serialize, serde::Deserialize)]
2589 #[derive()]
2590 pub enum HoprDummyProxyForNetworkRegistryCalls {
2591 #[allow(missing_docs)]
2592 MAX_REGISTRATION_PER_ACCOUNT(MAX_REGISTRATION_PER_ACCOUNTCall),
2593 #[allow(missing_docs)]
2594 canOperateFor(canOperateForCall),
2595 #[allow(missing_docs)]
2596 isAllAllowed(isAllAllowedCall),
2597 #[allow(missing_docs)]
2598 maxAllowedRegistrations(maxAllowedRegistrationsCall),
2599 #[allow(missing_docs)]
2600 owner(ownerCall),
2601 #[allow(missing_docs)]
2602 ownerAddAccount(ownerAddAccountCall),
2603 #[allow(missing_docs)]
2604 ownerBatchAddAccounts(ownerBatchAddAccountsCall),
2605 #[allow(missing_docs)]
2606 ownerBatchRemoveAccounts(ownerBatchRemoveAccountsCall),
2607 #[allow(missing_docs)]
2608 ownerRemoveAccount(ownerRemoveAccountCall),
2609 #[allow(missing_docs)]
2610 renounceOwnership(renounceOwnershipCall),
2611 #[allow(missing_docs)]
2612 transferOwnership(transferOwnershipCall),
2613 #[allow(missing_docs)]
2614 updateAllowAll(updateAllowAllCall),
2615 }
2616 #[automatically_derived]
2617 impl HoprDummyProxyForNetworkRegistryCalls {
2618 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2625 [8u8, 159u8, 250u8, 71u8],
2626 [64u8, 81u8, 242u8, 87u8],
2627 [72u8, 99u8, 84u8, 226u8],
2628 [92u8, 84u8, 113u8, 231u8],
2629 [113u8, 80u8, 24u8, 166u8],
2630 [141u8, 165u8, 203u8, 91u8],
2631 [167u8, 27u8, 27u8, 116u8],
2632 [179u8, 84u8, 78u8, 130u8],
2633 [216u8, 90u8, 208u8, 68u8],
2634 [242u8, 253u8, 227u8, 139u8],
2635 [244u8, 108u8, 132u8, 184u8],
2636 [246u8, 127u8, 94u8, 111u8],
2637 ];
2638 }
2639 #[automatically_derived]
2640 impl alloy_sol_types::SolInterface for HoprDummyProxyForNetworkRegistryCalls {
2641 const NAME: &'static str = "HoprDummyProxyForNetworkRegistryCalls";
2642 const MIN_DATA_LENGTH: usize = 0usize;
2643 const COUNT: usize = 12usize;
2644 #[inline]
2645 fn selector(&self) -> [u8; 4] {
2646 match self {
2647 Self::MAX_REGISTRATION_PER_ACCOUNT(_) => {
2648 <MAX_REGISTRATION_PER_ACCOUNTCall as alloy_sol_types::SolCall>::SELECTOR
2649 }
2650 Self::canOperateFor(_) => {
2651 <canOperateForCall as alloy_sol_types::SolCall>::SELECTOR
2652 }
2653 Self::isAllAllowed(_) => {
2654 <isAllAllowedCall as alloy_sol_types::SolCall>::SELECTOR
2655 }
2656 Self::maxAllowedRegistrations(_) => {
2657 <maxAllowedRegistrationsCall as alloy_sol_types::SolCall>::SELECTOR
2658 }
2659 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
2660 Self::ownerAddAccount(_) => {
2661 <ownerAddAccountCall as alloy_sol_types::SolCall>::SELECTOR
2662 }
2663 Self::ownerBatchAddAccounts(_) => {
2664 <ownerBatchAddAccountsCall as alloy_sol_types::SolCall>::SELECTOR
2665 }
2666 Self::ownerBatchRemoveAccounts(_) => {
2667 <ownerBatchRemoveAccountsCall as alloy_sol_types::SolCall>::SELECTOR
2668 }
2669 Self::ownerRemoveAccount(_) => {
2670 <ownerRemoveAccountCall as alloy_sol_types::SolCall>::SELECTOR
2671 }
2672 Self::renounceOwnership(_) => {
2673 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
2674 }
2675 Self::transferOwnership(_) => {
2676 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
2677 }
2678 Self::updateAllowAll(_) => {
2679 <updateAllowAllCall as alloy_sol_types::SolCall>::SELECTOR
2680 }
2681 }
2682 }
2683 #[inline]
2684 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2685 Self::SELECTORS.get(i).copied()
2686 }
2687 #[inline]
2688 fn valid_selector(selector: [u8; 4]) -> bool {
2689 Self::SELECTORS.binary_search(&selector).is_ok()
2690 }
2691 #[inline]
2692 #[allow(non_snake_case)]
2693 fn abi_decode_raw(
2694 selector: [u8; 4],
2695 data: &[u8],
2696 ) -> alloy_sol_types::Result<Self> {
2697 static DECODE_SHIMS: &[fn(
2698 &[u8],
2699 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls>] = &[
2700 {
2701 fn updateAllowAll(
2702 data: &[u8],
2703 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2704 <updateAllowAllCall as alloy_sol_types::SolCall>::abi_decode_raw(
2705 data,
2706 )
2707 .map(HoprDummyProxyForNetworkRegistryCalls::updateAllowAll)
2708 }
2709 updateAllowAll
2710 },
2711 {
2712 fn ownerRemoveAccount(
2713 data: &[u8],
2714 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2715 <ownerRemoveAccountCall as alloy_sol_types::SolCall>::abi_decode_raw(
2716 data,
2717 )
2718 .map(
2719 HoprDummyProxyForNetworkRegistryCalls::ownerRemoveAccount,
2720 )
2721 }
2722 ownerRemoveAccount
2723 },
2724 {
2725 fn ownerBatchAddAccounts(
2726 data: &[u8],
2727 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2728 <ownerBatchAddAccountsCall as alloy_sol_types::SolCall>::abi_decode_raw(
2729 data,
2730 )
2731 .map(
2732 HoprDummyProxyForNetworkRegistryCalls::ownerBatchAddAccounts,
2733 )
2734 }
2735 ownerBatchAddAccounts
2736 },
2737 {
2738 fn ownerBatchRemoveAccounts(
2739 data: &[u8],
2740 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2741 <ownerBatchRemoveAccountsCall as alloy_sol_types::SolCall>::abi_decode_raw(
2742 data,
2743 )
2744 .map(
2745 HoprDummyProxyForNetworkRegistryCalls::ownerBatchRemoveAccounts,
2746 )
2747 }
2748 ownerBatchRemoveAccounts
2749 },
2750 {
2751 fn renounceOwnership(
2752 data: &[u8],
2753 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2754 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
2755 data,
2756 )
2757 .map(
2758 HoprDummyProxyForNetworkRegistryCalls::renounceOwnership,
2759 )
2760 }
2761 renounceOwnership
2762 },
2763 {
2764 fn owner(
2765 data: &[u8],
2766 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2767 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
2768 .map(HoprDummyProxyForNetworkRegistryCalls::owner)
2769 }
2770 owner
2771 },
2772 {
2773 fn ownerAddAccount(
2774 data: &[u8],
2775 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2776 <ownerAddAccountCall as alloy_sol_types::SolCall>::abi_decode_raw(
2777 data,
2778 )
2779 .map(HoprDummyProxyForNetworkRegistryCalls::ownerAddAccount)
2780 }
2781 ownerAddAccount
2782 },
2783 {
2784 fn maxAllowedRegistrations(
2785 data: &[u8],
2786 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2787 <maxAllowedRegistrationsCall as alloy_sol_types::SolCall>::abi_decode_raw(
2788 data,
2789 )
2790 .map(
2791 HoprDummyProxyForNetworkRegistryCalls::maxAllowedRegistrations,
2792 )
2793 }
2794 maxAllowedRegistrations
2795 },
2796 {
2797 fn canOperateFor(
2798 data: &[u8],
2799 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2800 <canOperateForCall as alloy_sol_types::SolCall>::abi_decode_raw(
2801 data,
2802 )
2803 .map(HoprDummyProxyForNetworkRegistryCalls::canOperateFor)
2804 }
2805 canOperateFor
2806 },
2807 {
2808 fn transferOwnership(
2809 data: &[u8],
2810 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2811 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
2812 data,
2813 )
2814 .map(
2815 HoprDummyProxyForNetworkRegistryCalls::transferOwnership,
2816 )
2817 }
2818 transferOwnership
2819 },
2820 {
2821 fn MAX_REGISTRATION_PER_ACCOUNT(
2822 data: &[u8],
2823 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2824 <MAX_REGISTRATION_PER_ACCOUNTCall as alloy_sol_types::SolCall>::abi_decode_raw(
2825 data,
2826 )
2827 .map(
2828 HoprDummyProxyForNetworkRegistryCalls::MAX_REGISTRATION_PER_ACCOUNT,
2829 )
2830 }
2831 MAX_REGISTRATION_PER_ACCOUNT
2832 },
2833 {
2834 fn isAllAllowed(
2835 data: &[u8],
2836 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2837 <isAllAllowedCall as alloy_sol_types::SolCall>::abi_decode_raw(
2838 data,
2839 )
2840 .map(HoprDummyProxyForNetworkRegistryCalls::isAllAllowed)
2841 }
2842 isAllAllowed
2843 },
2844 ];
2845 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2846 return Err(
2847 alloy_sol_types::Error::unknown_selector(
2848 <Self as alloy_sol_types::SolInterface>::NAME,
2849 selector,
2850 ),
2851 );
2852 };
2853 DECODE_SHIMS[idx](data)
2854 }
2855 #[inline]
2856 #[allow(non_snake_case)]
2857 fn abi_decode_raw_validate(
2858 selector: [u8; 4],
2859 data: &[u8],
2860 ) -> alloy_sol_types::Result<Self> {
2861 static DECODE_VALIDATE_SHIMS: &[fn(
2862 &[u8],
2863 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls>] = &[
2864 {
2865 fn updateAllowAll(
2866 data: &[u8],
2867 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2868 <updateAllowAllCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2869 data,
2870 )
2871 .map(HoprDummyProxyForNetworkRegistryCalls::updateAllowAll)
2872 }
2873 updateAllowAll
2874 },
2875 {
2876 fn ownerRemoveAccount(
2877 data: &[u8],
2878 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2879 <ownerRemoveAccountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2880 data,
2881 )
2882 .map(
2883 HoprDummyProxyForNetworkRegistryCalls::ownerRemoveAccount,
2884 )
2885 }
2886 ownerRemoveAccount
2887 },
2888 {
2889 fn ownerBatchAddAccounts(
2890 data: &[u8],
2891 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2892 <ownerBatchAddAccountsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2893 data,
2894 )
2895 .map(
2896 HoprDummyProxyForNetworkRegistryCalls::ownerBatchAddAccounts,
2897 )
2898 }
2899 ownerBatchAddAccounts
2900 },
2901 {
2902 fn ownerBatchRemoveAccounts(
2903 data: &[u8],
2904 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2905 <ownerBatchRemoveAccountsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2906 data,
2907 )
2908 .map(
2909 HoprDummyProxyForNetworkRegistryCalls::ownerBatchRemoveAccounts,
2910 )
2911 }
2912 ownerBatchRemoveAccounts
2913 },
2914 {
2915 fn renounceOwnership(
2916 data: &[u8],
2917 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2918 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2919 data,
2920 )
2921 .map(
2922 HoprDummyProxyForNetworkRegistryCalls::renounceOwnership,
2923 )
2924 }
2925 renounceOwnership
2926 },
2927 {
2928 fn owner(
2929 data: &[u8],
2930 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2931 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2932 data,
2933 )
2934 .map(HoprDummyProxyForNetworkRegistryCalls::owner)
2935 }
2936 owner
2937 },
2938 {
2939 fn ownerAddAccount(
2940 data: &[u8],
2941 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2942 <ownerAddAccountCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2943 data,
2944 )
2945 .map(HoprDummyProxyForNetworkRegistryCalls::ownerAddAccount)
2946 }
2947 ownerAddAccount
2948 },
2949 {
2950 fn maxAllowedRegistrations(
2951 data: &[u8],
2952 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2953 <maxAllowedRegistrationsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2954 data,
2955 )
2956 .map(
2957 HoprDummyProxyForNetworkRegistryCalls::maxAllowedRegistrations,
2958 )
2959 }
2960 maxAllowedRegistrations
2961 },
2962 {
2963 fn canOperateFor(
2964 data: &[u8],
2965 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2966 <canOperateForCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2967 data,
2968 )
2969 .map(HoprDummyProxyForNetworkRegistryCalls::canOperateFor)
2970 }
2971 canOperateFor
2972 },
2973 {
2974 fn transferOwnership(
2975 data: &[u8],
2976 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2977 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2978 data,
2979 )
2980 .map(
2981 HoprDummyProxyForNetworkRegistryCalls::transferOwnership,
2982 )
2983 }
2984 transferOwnership
2985 },
2986 {
2987 fn MAX_REGISTRATION_PER_ACCOUNT(
2988 data: &[u8],
2989 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
2990 <MAX_REGISTRATION_PER_ACCOUNTCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2991 data,
2992 )
2993 .map(
2994 HoprDummyProxyForNetworkRegistryCalls::MAX_REGISTRATION_PER_ACCOUNT,
2995 )
2996 }
2997 MAX_REGISTRATION_PER_ACCOUNT
2998 },
2999 {
3000 fn isAllAllowed(
3001 data: &[u8],
3002 ) -> alloy_sol_types::Result<HoprDummyProxyForNetworkRegistryCalls> {
3003 <isAllAllowedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3004 data,
3005 )
3006 .map(HoprDummyProxyForNetworkRegistryCalls::isAllAllowed)
3007 }
3008 isAllAllowed
3009 },
3010 ];
3011 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3012 return Err(
3013 alloy_sol_types::Error::unknown_selector(
3014 <Self as alloy_sol_types::SolInterface>::NAME,
3015 selector,
3016 ),
3017 );
3018 };
3019 DECODE_VALIDATE_SHIMS[idx](data)
3020 }
3021 #[inline]
3022 fn abi_encoded_size(&self) -> usize {
3023 match self {
3024 Self::MAX_REGISTRATION_PER_ACCOUNT(inner) => {
3025 <MAX_REGISTRATION_PER_ACCOUNTCall as alloy_sol_types::SolCall>::abi_encoded_size(
3026 inner,
3027 )
3028 }
3029 Self::canOperateFor(inner) => {
3030 <canOperateForCall as alloy_sol_types::SolCall>::abi_encoded_size(
3031 inner,
3032 )
3033 }
3034 Self::isAllAllowed(inner) => {
3035 <isAllAllowedCall as alloy_sol_types::SolCall>::abi_encoded_size(
3036 inner,
3037 )
3038 }
3039 Self::maxAllowedRegistrations(inner) => {
3040 <maxAllowedRegistrationsCall as alloy_sol_types::SolCall>::abi_encoded_size(
3041 inner,
3042 )
3043 }
3044 Self::owner(inner) => {
3045 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
3046 }
3047 Self::ownerAddAccount(inner) => {
3048 <ownerAddAccountCall as alloy_sol_types::SolCall>::abi_encoded_size(
3049 inner,
3050 )
3051 }
3052 Self::ownerBatchAddAccounts(inner) => {
3053 <ownerBatchAddAccountsCall as alloy_sol_types::SolCall>::abi_encoded_size(
3054 inner,
3055 )
3056 }
3057 Self::ownerBatchRemoveAccounts(inner) => {
3058 <ownerBatchRemoveAccountsCall as alloy_sol_types::SolCall>::abi_encoded_size(
3059 inner,
3060 )
3061 }
3062 Self::ownerRemoveAccount(inner) => {
3063 <ownerRemoveAccountCall as alloy_sol_types::SolCall>::abi_encoded_size(
3064 inner,
3065 )
3066 }
3067 Self::renounceOwnership(inner) => {
3068 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
3069 inner,
3070 )
3071 }
3072 Self::transferOwnership(inner) => {
3073 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
3074 inner,
3075 )
3076 }
3077 Self::updateAllowAll(inner) => {
3078 <updateAllowAllCall as alloy_sol_types::SolCall>::abi_encoded_size(
3079 inner,
3080 )
3081 }
3082 }
3083 }
3084 #[inline]
3085 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
3086 match self {
3087 Self::MAX_REGISTRATION_PER_ACCOUNT(inner) => {
3088 <MAX_REGISTRATION_PER_ACCOUNTCall as alloy_sol_types::SolCall>::abi_encode_raw(
3089 inner,
3090 out,
3091 )
3092 }
3093 Self::canOperateFor(inner) => {
3094 <canOperateForCall as alloy_sol_types::SolCall>::abi_encode_raw(
3095 inner,
3096 out,
3097 )
3098 }
3099 Self::isAllAllowed(inner) => {
3100 <isAllAllowedCall as alloy_sol_types::SolCall>::abi_encode_raw(
3101 inner,
3102 out,
3103 )
3104 }
3105 Self::maxAllowedRegistrations(inner) => {
3106 <maxAllowedRegistrationsCall as alloy_sol_types::SolCall>::abi_encode_raw(
3107 inner,
3108 out,
3109 )
3110 }
3111 Self::owner(inner) => {
3112 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
3113 }
3114 Self::ownerAddAccount(inner) => {
3115 <ownerAddAccountCall as alloy_sol_types::SolCall>::abi_encode_raw(
3116 inner,
3117 out,
3118 )
3119 }
3120 Self::ownerBatchAddAccounts(inner) => {
3121 <ownerBatchAddAccountsCall as alloy_sol_types::SolCall>::abi_encode_raw(
3122 inner,
3123 out,
3124 )
3125 }
3126 Self::ownerBatchRemoveAccounts(inner) => {
3127 <ownerBatchRemoveAccountsCall as alloy_sol_types::SolCall>::abi_encode_raw(
3128 inner,
3129 out,
3130 )
3131 }
3132 Self::ownerRemoveAccount(inner) => {
3133 <ownerRemoveAccountCall as alloy_sol_types::SolCall>::abi_encode_raw(
3134 inner,
3135 out,
3136 )
3137 }
3138 Self::renounceOwnership(inner) => {
3139 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
3140 inner,
3141 out,
3142 )
3143 }
3144 Self::transferOwnership(inner) => {
3145 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
3146 inner,
3147 out,
3148 )
3149 }
3150 Self::updateAllowAll(inner) => {
3151 <updateAllowAllCall as alloy_sol_types::SolCall>::abi_encode_raw(
3152 inner,
3153 out,
3154 )
3155 }
3156 }
3157 }
3158 }
3159 #[derive(serde::Serialize, serde::Deserialize)]
3161 #[derive(Debug, PartialEq, Eq, Hash)]
3162 pub enum HoprDummyProxyForNetworkRegistryEvents {
3163 #[allow(missing_docs)]
3164 AccountDeregistered(AccountDeregistered),
3165 #[allow(missing_docs)]
3166 AccountRegistered(AccountRegistered),
3167 #[allow(missing_docs)]
3168 AllowAllAccountsEligible(AllowAllAccountsEligible),
3169 #[allow(missing_docs)]
3170 OwnershipTransferred(OwnershipTransferred),
3171 }
3172 #[automatically_derived]
3173 impl HoprDummyProxyForNetworkRegistryEvents {
3174 pub const SELECTORS: &'static [[u8; 32usize]] = &[
3181 [
3182 14u8, 99u8, 214u8, 41u8, 175u8, 227u8, 75u8, 60u8, 165u8, 16u8, 124u8,
3183 16u8, 249u8, 10u8, 191u8, 245u8, 9u8, 27u8, 49u8, 85u8, 27u8, 55u8, 23u8,
3184 88u8, 189u8, 80u8, 175u8, 118u8, 131u8, 77u8, 192u8, 116u8,
3185 ],
3186 [
3187 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
3188 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
3189 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
3190 ],
3191 [
3192 175u8, 171u8, 35u8, 164u8, 188u8, 140u8, 73u8, 37u8, 11u8, 163u8, 126u8,
3193 235u8, 6u8, 37u8, 176u8, 169u8, 178u8, 113u8, 245u8, 93u8, 21u8, 1u8,
3194 131u8, 141u8, 36u8, 245u8, 69u8, 8u8, 195u8, 177u8, 115u8, 66u8,
3195 ],
3196 [
3197 205u8, 130u8, 45u8, 201u8, 104u8, 142u8, 32u8, 172u8, 234u8, 104u8,
3198 114u8, 74u8, 47u8, 188u8, 254u8, 79u8, 62u8, 82u8, 109u8, 32u8, 236u8,
3199 170u8, 55u8, 177u8, 143u8, 227u8, 4u8, 122u8, 179u8, 119u8, 214u8, 165u8,
3200 ],
3201 ];
3202 }
3203 #[automatically_derived]
3204 impl alloy_sol_types::SolEventInterface for HoprDummyProxyForNetworkRegistryEvents {
3205 const NAME: &'static str = "HoprDummyProxyForNetworkRegistryEvents";
3206 const COUNT: usize = 4usize;
3207 fn decode_raw_log(
3208 topics: &[alloy_sol_types::Word],
3209 data: &[u8],
3210 ) -> alloy_sol_types::Result<Self> {
3211 match topics.first().copied() {
3212 Some(
3213 <AccountDeregistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
3214 ) => {
3215 <AccountDeregistered as alloy_sol_types::SolEvent>::decode_raw_log(
3216 topics,
3217 data,
3218 )
3219 .map(Self::AccountDeregistered)
3220 }
3221 Some(
3222 <AccountRegistered as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
3223 ) => {
3224 <AccountRegistered as alloy_sol_types::SolEvent>::decode_raw_log(
3225 topics,
3226 data,
3227 )
3228 .map(Self::AccountRegistered)
3229 }
3230 Some(
3231 <AllowAllAccountsEligible as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
3232 ) => {
3233 <AllowAllAccountsEligible as alloy_sol_types::SolEvent>::decode_raw_log(
3234 topics,
3235 data,
3236 )
3237 .map(Self::AllowAllAccountsEligible)
3238 }
3239 Some(
3240 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
3241 ) => {
3242 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
3243 topics,
3244 data,
3245 )
3246 .map(Self::OwnershipTransferred)
3247 }
3248 _ => {
3249 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
3250 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
3251 log: alloy_sol_types::private::Box::new(
3252 alloy_sol_types::private::LogData::new_unchecked(
3253 topics.to_vec(),
3254 data.to_vec().into(),
3255 ),
3256 ),
3257 })
3258 }
3259 }
3260 }
3261 }
3262 #[automatically_derived]
3263 impl alloy_sol_types::private::IntoLogData
3264 for HoprDummyProxyForNetworkRegistryEvents {
3265 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3266 match self {
3267 Self::AccountDeregistered(inner) => {
3268 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3269 }
3270 Self::AccountRegistered(inner) => {
3271 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3272 }
3273 Self::AllowAllAccountsEligible(inner) => {
3274 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3275 }
3276 Self::OwnershipTransferred(inner) => {
3277 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3278 }
3279 }
3280 }
3281 fn into_log_data(self) -> alloy_sol_types::private::LogData {
3282 match self {
3283 Self::AccountDeregistered(inner) => {
3284 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3285 }
3286 Self::AccountRegistered(inner) => {
3287 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3288 }
3289 Self::AllowAllAccountsEligible(inner) => {
3290 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3291 }
3292 Self::OwnershipTransferred(inner) => {
3293 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3294 }
3295 }
3296 }
3297 }
3298 use alloy::contract as alloy_contract;
3299 #[inline]
3303 pub const fn new<
3304 P: alloy_contract::private::Provider<N>,
3305 N: alloy_contract::private::Network,
3306 >(
3307 address: alloy_sol_types::private::Address,
3308 provider: P,
3309 ) -> HoprDummyProxyForNetworkRegistryInstance<P, N> {
3310 HoprDummyProxyForNetworkRegistryInstance::<P, N>::new(address, provider)
3311 }
3312 #[inline]
3318 pub fn deploy<
3319 P: alloy_contract::private::Provider<N>,
3320 N: alloy_contract::private::Network,
3321 >(
3322 provider: P,
3323 newOwner: alloy::sol_types::private::Address,
3324 ) -> impl ::core::future::Future<
3325 Output = alloy_contract::Result<HoprDummyProxyForNetworkRegistryInstance<P, N>>,
3326 > {
3327 HoprDummyProxyForNetworkRegistryInstance::<P, N>::deploy(provider, newOwner)
3328 }
3329 #[inline]
3335 pub fn deploy_builder<
3336 P: alloy_contract::private::Provider<N>,
3337 N: alloy_contract::private::Network,
3338 >(
3339 provider: P,
3340 newOwner: alloy::sol_types::private::Address,
3341 ) -> alloy_contract::RawCallBuilder<P, N> {
3342 HoprDummyProxyForNetworkRegistryInstance::<
3343 P,
3344 N,
3345 >::deploy_builder(provider, newOwner)
3346 }
3347 #[derive(Clone)]
3359 pub struct HoprDummyProxyForNetworkRegistryInstance<
3360 P,
3361 N = alloy_contract::private::Ethereum,
3362 > {
3363 address: alloy_sol_types::private::Address,
3364 provider: P,
3365 _network: ::core::marker::PhantomData<N>,
3366 }
3367 #[automatically_derived]
3368 impl<P, N> ::core::fmt::Debug for HoprDummyProxyForNetworkRegistryInstance<P, N> {
3369 #[inline]
3370 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3371 f.debug_tuple("HoprDummyProxyForNetworkRegistryInstance")
3372 .field(&self.address)
3373 .finish()
3374 }
3375 }
3376 #[automatically_derived]
3378 impl<
3379 P: alloy_contract::private::Provider<N>,
3380 N: alloy_contract::private::Network,
3381 > HoprDummyProxyForNetworkRegistryInstance<P, N> {
3382 #[inline]
3386 pub const fn new(
3387 address: alloy_sol_types::private::Address,
3388 provider: P,
3389 ) -> Self {
3390 Self {
3391 address,
3392 provider,
3393 _network: ::core::marker::PhantomData,
3394 }
3395 }
3396 #[inline]
3402 pub async fn deploy(
3403 provider: P,
3404 newOwner: alloy::sol_types::private::Address,
3405 ) -> alloy_contract::Result<HoprDummyProxyForNetworkRegistryInstance<P, N>> {
3406 let call_builder = Self::deploy_builder(provider, newOwner);
3407 let contract_address = call_builder.deploy().await?;
3408 Ok(Self::new(contract_address, call_builder.provider))
3409 }
3410 #[inline]
3416 pub fn deploy_builder(
3417 provider: P,
3418 newOwner: alloy::sol_types::private::Address,
3419 ) -> alloy_contract::RawCallBuilder<P, N> {
3420 alloy_contract::RawCallBuilder::new_raw_deploy(
3421 provider,
3422 [
3423 &BYTECODE[..],
3424 &alloy_sol_types::SolConstructor::abi_encode(
3425 &constructorCall { newOwner },
3426 )[..],
3427 ]
3428 .concat()
3429 .into(),
3430 )
3431 }
3432 #[inline]
3434 pub const fn address(&self) -> &alloy_sol_types::private::Address {
3435 &self.address
3436 }
3437 #[inline]
3439 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
3440 self.address = address;
3441 }
3442 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
3444 self.set_address(address);
3445 self
3446 }
3447 #[inline]
3449 pub const fn provider(&self) -> &P {
3450 &self.provider
3451 }
3452 }
3453 impl<P: ::core::clone::Clone, N> HoprDummyProxyForNetworkRegistryInstance<&P, N> {
3454 #[inline]
3456 pub fn with_cloned_provider(
3457 self,
3458 ) -> HoprDummyProxyForNetworkRegistryInstance<P, N> {
3459 HoprDummyProxyForNetworkRegistryInstance {
3460 address: self.address,
3461 provider: ::core::clone::Clone::clone(&self.provider),
3462 _network: ::core::marker::PhantomData,
3463 }
3464 }
3465 }
3466 #[automatically_derived]
3468 impl<
3469 P: alloy_contract::private::Provider<N>,
3470 N: alloy_contract::private::Network,
3471 > HoprDummyProxyForNetworkRegistryInstance<P, N> {
3472 pub fn call_builder<C: alloy_sol_types::SolCall>(
3477 &self,
3478 call: &C,
3479 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
3480 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
3481 }
3482 pub fn MAX_REGISTRATION_PER_ACCOUNT(
3484 &self,
3485 ) -> alloy_contract::SolCallBuilder<&P, MAX_REGISTRATION_PER_ACCOUNTCall, N> {
3486 self.call_builder(&MAX_REGISTRATION_PER_ACCOUNTCall)
3487 }
3488 pub fn canOperateFor(
3490 &self,
3491 _0: alloy::sol_types::private::Address,
3492 _1: alloy::sol_types::private::Address,
3493 ) -> alloy_contract::SolCallBuilder<&P, canOperateForCall, N> {
3494 self.call_builder(&canOperateForCall { _0, _1 })
3495 }
3496 pub fn isAllAllowed(
3498 &self,
3499 ) -> alloy_contract::SolCallBuilder<&P, isAllAllowedCall, N> {
3500 self.call_builder(&isAllAllowedCall)
3501 }
3502 pub fn maxAllowedRegistrations(
3504 &self,
3505 account: alloy::sol_types::private::Address,
3506 ) -> alloy_contract::SolCallBuilder<&P, maxAllowedRegistrationsCall, N> {
3507 self.call_builder(
3508 &maxAllowedRegistrationsCall {
3509 account,
3510 },
3511 )
3512 }
3513 pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
3515 self.call_builder(&ownerCall)
3516 }
3517 pub fn ownerAddAccount(
3519 &self,
3520 account: alloy::sol_types::private::Address,
3521 ) -> alloy_contract::SolCallBuilder<&P, ownerAddAccountCall, N> {
3522 self.call_builder(&ownerAddAccountCall { account })
3523 }
3524 pub fn ownerBatchAddAccounts(
3526 &self,
3527 accounts: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3528 ) -> alloy_contract::SolCallBuilder<&P, ownerBatchAddAccountsCall, N> {
3529 self.call_builder(
3530 &ownerBatchAddAccountsCall {
3531 accounts,
3532 },
3533 )
3534 }
3535 pub fn ownerBatchRemoveAccounts(
3537 &self,
3538 accounts: alloy::sol_types::private::Vec<alloy::sol_types::private::Address>,
3539 ) -> alloy_contract::SolCallBuilder<&P, ownerBatchRemoveAccountsCall, N> {
3540 self.call_builder(
3541 &ownerBatchRemoveAccountsCall {
3542 accounts,
3543 },
3544 )
3545 }
3546 pub fn ownerRemoveAccount(
3548 &self,
3549 account: alloy::sol_types::private::Address,
3550 ) -> alloy_contract::SolCallBuilder<&P, ownerRemoveAccountCall, N> {
3551 self.call_builder(&ownerRemoveAccountCall { account })
3552 }
3553 pub fn renounceOwnership(
3555 &self,
3556 ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
3557 self.call_builder(&renounceOwnershipCall)
3558 }
3559 pub fn transferOwnership(
3561 &self,
3562 newOwner: alloy::sol_types::private::Address,
3563 ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
3564 self.call_builder(&transferOwnershipCall { newOwner })
3565 }
3566 pub fn updateAllowAll(
3568 &self,
3569 _updatedAllow: bool,
3570 ) -> alloy_contract::SolCallBuilder<&P, updateAllowAllCall, N> {
3571 self.call_builder(
3572 &updateAllowAllCall {
3573 _updatedAllow,
3574 },
3575 )
3576 }
3577 }
3578 #[automatically_derived]
3580 impl<
3581 P: alloy_contract::private::Provider<N>,
3582 N: alloy_contract::private::Network,
3583 > HoprDummyProxyForNetworkRegistryInstance<P, N> {
3584 pub fn event_filter<E: alloy_sol_types::SolEvent>(
3589 &self,
3590 ) -> alloy_contract::Event<&P, E, N> {
3591 alloy_contract::Event::new_sol(&self.provider, &self.address)
3592 }
3593 pub fn AccountDeregistered_filter(
3595 &self,
3596 ) -> alloy_contract::Event<&P, AccountDeregistered, N> {
3597 self.event_filter::<AccountDeregistered>()
3598 }
3599 pub fn AccountRegistered_filter(
3601 &self,
3602 ) -> alloy_contract::Event<&P, AccountRegistered, N> {
3603 self.event_filter::<AccountRegistered>()
3604 }
3605 pub fn AllowAllAccountsEligible_filter(
3607 &self,
3608 ) -> alloy_contract::Event<&P, AllowAllAccountsEligible, N> {
3609 self.event_filter::<AllowAllAccountsEligible>()
3610 }
3611 pub fn OwnershipTransferred_filter(
3613 &self,
3614 ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
3615 self.event_filter::<OwnershipTransferred>()
3616 }
3617 }
3618}