1#[allow(
189 non_camel_case_types,
190 non_snake_case,
191 clippy::pub_underscore_fields,
192 clippy::style,
193 clippy::empty_structs_with_brackets
194)]
195pub mod HoprWinningProbabilityOracle {
196 use super::*;
197 use alloy::sol_types as alloy_sol_types;
198 #[rustfmt::skip]
204 #[allow(clippy::all)]
205 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
206 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x05\xC78\x03\x80a\x05\xC7\x839\x81\x01`@\x81\x90Ra\0/\x91a\x010V[a\083a\0QV[a\0A\x82a\0QV[a\0J\x81a\0mV[PPa\x01\x82V[`\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90Ua\0j\x81a\0\xE0V[PV[`\x01\x80Tf\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16`\x01`\xA0\x1B\x90\x81\x02f\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\xA0\x1B\x19\x84\x16\x17\x93\x84\x90U`@\x80Q\x93\x82\x90\x04\x83\x16\x80\x85R\x91\x90\x94\x04\x90\x91\x16` \x83\x01R\x91\x7F\x02r\x8CJ\x807?GeU\x9D\xC3\xA0F\xED\xEA\x88\x18d$\x82r8\xBBF$Vh1]8\0\x91\x01`@Q\x80\x91\x03\x90\xA1PPV[`\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\x80`@\x83\x85\x03\x12\x15a\x01CW`\0\x80\xFD[\x82Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x01ZW`\0\x80\xFD[` \x84\x01Q\x90\x92Pf\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x01wW`\0\x80\xFD[\x80\x91PP\x92P\x92\x90PV[a\x046\x80a\x01\x91`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0}W`\x005`\xE0\x1C\x80c\x8D\xA5\xCB[\x11a\0[W\x80c\x8D\xA5\xCB[\x14a\0\xCBW\x80c\xE3\x0C9x\x14a\0\xF0W\x80c\xF2\xFD\xE3\x8B\x14a\x01\x01W\x80c\xFD\xE4o\xF8\x14a\x01\x14W`\0\x80\xFD[\x80c\x16\x8E\x91`\x14a\0\x82W\x80cqP\x18\xA6\x14a\0\xB9W\x80cy\xBAP\x97\x14a\0\xC3W[`\0\x80\xFD[`\x01Ta\0\x9C\x90`\x01`\xA0\x1B\x90\x04f\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`@Qf\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xC1a\x01'V[\0[a\0\xC1a\x01;V[`\0T`\x01`\x01`\xA0\x1B\x03\x16[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\xB0V[`\x01T`\x01`\x01`\xA0\x1B\x03\x16a\0\xD8V[a\0\xC1a\x01\x0F6`\x04a\x03\xA7V[a\x01\xBAV[a\0\xC1a\x01\"6`\x04a\x03\xD7V[a\x02+V[a\x01/a\x02qV[a\x019`\0a\x02\xCBV[V[`\x01T3\x90`\x01`\x01`\xA0\x1B\x03\x16\x81\x14a\x01\xAEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FOwnable2Step: caller is not the `D\x82\x01Rh72\xBB\x907\xBB\xB72\xB9`\xB9\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[a\x01\xB7\x81a\x02\xCBV[PV[a\x01\xC2a\x02qV[`\x01\x80T`\x01`\x01`\xA0\x1B\x03\x83\x16`\x01`\x01`\xA0\x1B\x03\x19\x90\x91\x16\x81\x17\x90\x91Ua\x01\xF3`\0T`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x7F8\xD1k\x8C\xAC\"\xD9\x9F\xC7\xC1$\xB9\xCD\r\xE2\xD3\xFA\x1F\xAE\xF4 \xBF\xE7\x91\xD8\xC3b\xD7e\xE2'\0`@Q`@Q\x80\x91\x03\x90\xA3PV[a\x023a\x02qV[`\x01Tf\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16`\x01`\xA0\x1B\x90\x92\x04\x16\x03a\x02hW`@Qc6\xBF\x1F\xCD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xB7\x81a\x02\xE4V[`\0T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x019W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x01\xA5V[`\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90Ua\x01\xB7\x81a\x03WV[`\x01\x80Tf\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16`\x01`\xA0\x1B\x90\x81\x02f\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\xA0\x1B\x19\x84\x16\x17\x93\x84\x90U`@\x80Q\x93\x82\x90\x04\x83\x16\x80\x85R\x91\x90\x94\x04\x90\x91\x16` \x83\x01R\x91\x7F\x02r\x8CJ\x807?GeU\x9D\xC3\xA0F\xED\xEA\x88\x18d$\x82r8\xBBF$Vh1]8\0\x91\x01`@Q\x80\x91\x03\x90\xA1PPV[`\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\x03\xB9W`\0\x80\xFD[\x815`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x03\xD0W`\0\x80\xFD[\x93\x92PPPV[`\0` \x82\x84\x03\x12\x15a\x03\xE9W`\0\x80\xFD[\x815f\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x03\xD0W`\0\x80\xFD\xFE\xA2dipfsX\"\x12 \xEB\xC7->e\xDC:\x08\x1F\xE6\xE8I(\x162\x931\x8D\t\x86\rG\x1C\xE1\xC1\x80v\xE7\xA6aH*dsolcC\0\x08\x13\x003",
207 );
208 #[rustfmt::skip]
214 #[allow(clippy::all)]
215 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
216 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0}W`\x005`\xE0\x1C\x80c\x8D\xA5\xCB[\x11a\0[W\x80c\x8D\xA5\xCB[\x14a\0\xCBW\x80c\xE3\x0C9x\x14a\0\xF0W\x80c\xF2\xFD\xE3\x8B\x14a\x01\x01W\x80c\xFD\xE4o\xF8\x14a\x01\x14W`\0\x80\xFD[\x80c\x16\x8E\x91`\x14a\0\x82W\x80cqP\x18\xA6\x14a\0\xB9W\x80cy\xBAP\x97\x14a\0\xC3W[`\0\x80\xFD[`\x01Ta\0\x9C\x90`\x01`\xA0\x1B\x90\x04f\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x16\x81V[`@Qf\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xC1a\x01'V[\0[a\0\xC1a\x01;V[`\0T`\x01`\x01`\xA0\x1B\x03\x16[`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01a\0\xB0V[`\x01T`\x01`\x01`\xA0\x1B\x03\x16a\0\xD8V[a\0\xC1a\x01\x0F6`\x04a\x03\xA7V[a\x01\xBAV[a\0\xC1a\x01\"6`\x04a\x03\xD7V[a\x02+V[a\x01/a\x02qV[a\x019`\0a\x02\xCBV[V[`\x01T3\x90`\x01`\x01`\xA0\x1B\x03\x16\x81\x14a\x01\xAEW`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01R`)`$\x82\x01R\x7FOwnable2Step: caller is not the `D\x82\x01Rh72\xBB\x907\xBB\xB72\xB9`\xB9\x1B`d\x82\x01R`\x84\x01[`@Q\x80\x91\x03\x90\xFD[a\x01\xB7\x81a\x02\xCBV[PV[a\x01\xC2a\x02qV[`\x01\x80T`\x01`\x01`\xA0\x1B\x03\x83\x16`\x01`\x01`\xA0\x1B\x03\x19\x90\x91\x16\x81\x17\x90\x91Ua\x01\xF3`\0T`\x01`\x01`\xA0\x1B\x03\x16\x90V[`\x01`\x01`\xA0\x1B\x03\x16\x7F8\xD1k\x8C\xAC\"\xD9\x9F\xC7\xC1$\xB9\xCD\r\xE2\xD3\xFA\x1F\xAE\xF4 \xBF\xE7\x91\xD8\xC3b\xD7e\xE2'\0`@Q`@Q\x80\x91\x03\x90\xA3PV[a\x023a\x02qV[`\x01Tf\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x80\x83\x16`\x01`\xA0\x1B\x90\x92\x04\x16\x03a\x02hW`@Qc6\xBF\x1F\xCD`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[a\x01\xB7\x81a\x02\xE4V[`\0T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x019W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x01\xA5V[`\x01\x80T`\x01`\x01`\xA0\x1B\x03\x19\x16\x90Ua\x01\xB7\x81a\x03WV[`\x01\x80Tf\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x83\x81\x16`\x01`\xA0\x1B\x90\x81\x02f\xFF\xFF\xFF\xFF\xFF\xFF\xFF`\xA0\x1B\x19\x84\x16\x17\x93\x84\x90U`@\x80Q\x93\x82\x90\x04\x83\x16\x80\x85R\x91\x90\x94\x04\x90\x91\x16` \x83\x01R\x91\x7F\x02r\x8CJ\x807?GeU\x9D\xC3\xA0F\xED\xEA\x88\x18d$\x82r8\xBBF$Vh1]8\0\x91\x01`@Q\x80\x91\x03\x90\xA1PPV[`\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\x03\xB9W`\0\x80\xFD[\x815`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x03\xD0W`\0\x80\xFD[\x93\x92PPPV[`\0` \x82\x84\x03\x12\x15a\x03\xE9W`\0\x80\xFD[\x815f\xFF\xFF\xFF\xFF\xFF\xFF\xFF\x81\x16\x81\x14a\x03\xD0W`\0\x80\xFD\xFE\xA2dipfsX\"\x12 \xEB\xC7->e\xDC:\x08\x1F\xE6\xE8I(\x162\x931\x8D\t\x86\rG\x1C\xE1\xC1\x80v\xE7\xA6aH*dsolcC\0\x08\x13\x003",
217 );
218 #[derive(serde::Serialize, serde::Deserialize)]
219 #[derive(Default, Debug, PartialEq, Eq, Hash)]
220 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
221 #[derive(Clone)]
222 pub struct WinProb(alloy::sol_types::private::primitives::aliases::U56);
223 const _: () = {
224 use alloy::sol_types as alloy_sol_types;
225 #[automatically_derived]
226 impl alloy_sol_types::private::SolTypeValue<WinProb>
227 for alloy::sol_types::private::primitives::aliases::U56 {
228 #[inline]
229 fn stv_to_tokens(
230 &self,
231 ) -> <alloy::sol_types::sol_data::Uint<
232 56,
233 > as alloy_sol_types::SolType>::Token<'_> {
234 alloy_sol_types::private::SolTypeValue::<
235 alloy::sol_types::sol_data::Uint<56>,
236 >::stv_to_tokens(self)
237 }
238 #[inline]
239 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
240 <alloy::sol_types::sol_data::Uint<
241 56,
242 > as alloy_sol_types::SolType>::tokenize(self)
243 .0
244 }
245 #[inline]
246 fn stv_abi_encode_packed_to(
247 &self,
248 out: &mut alloy_sol_types::private::Vec<u8>,
249 ) {
250 <alloy::sol_types::sol_data::Uint<
251 56,
252 > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
253 }
254 #[inline]
255 fn stv_abi_packed_encoded_size(&self) -> usize {
256 <alloy::sol_types::sol_data::Uint<
257 56,
258 > as alloy_sol_types::SolType>::abi_encoded_size(self)
259 }
260 }
261 #[automatically_derived]
262 impl WinProb {
263 pub const NAME: &'static str = stringify!(@ name);
265 #[inline]
267 pub const fn from_underlying(
268 value: alloy::sol_types::private::primitives::aliases::U56,
269 ) -> Self {
270 Self(value)
271 }
272 #[inline]
274 pub const fn into_underlying(
275 self,
276 ) -> alloy::sol_types::private::primitives::aliases::U56 {
277 self.0
278 }
279 #[inline]
282 pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
283 <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
284 }
285 #[inline]
288 pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
289 <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
290 }
291 }
292 #[automatically_derived]
293 impl From<alloy::sol_types::private::primitives::aliases::U56> for WinProb {
294 fn from(value: alloy::sol_types::private::primitives::aliases::U56) -> Self {
295 Self::from_underlying(value)
296 }
297 }
298 #[automatically_derived]
299 impl From<WinProb> for alloy::sol_types::private::primitives::aliases::U56 {
300 fn from(value: WinProb) -> Self {
301 value.into_underlying()
302 }
303 }
304 #[automatically_derived]
305 impl alloy_sol_types::SolType for WinProb {
306 type RustType = alloy::sol_types::private::primitives::aliases::U56;
307 type Token<'a> = <alloy::sol_types::sol_data::Uint<
308 56,
309 > as alloy_sol_types::SolType>::Token<'a>;
310 const SOL_NAME: &'static str = Self::NAME;
311 const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
312 56,
313 > as alloy_sol_types::SolType>::ENCODED_SIZE;
314 const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
315 56,
316 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
317 #[inline]
318 fn valid_token(token: &Self::Token<'_>) -> bool {
319 Self::type_check(token).is_ok()
320 }
321 #[inline]
322 fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
323 <alloy::sol_types::sol_data::Uint<
324 56,
325 > as alloy_sol_types::SolType>::type_check(token)
326 }
327 #[inline]
328 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
329 <alloy::sol_types::sol_data::Uint<
330 56,
331 > as alloy_sol_types::SolType>::detokenize(token)
332 }
333 }
334 #[automatically_derived]
335 impl alloy_sol_types::EventTopic for WinProb {
336 #[inline]
337 fn topic_preimage_length(rust: &Self::RustType) -> usize {
338 <alloy::sol_types::sol_data::Uint<
339 56,
340 > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
341 }
342 #[inline]
343 fn encode_topic_preimage(
344 rust: &Self::RustType,
345 out: &mut alloy_sol_types::private::Vec<u8>,
346 ) {
347 <alloy::sol_types::sol_data::Uint<
348 56,
349 > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
350 }
351 #[inline]
352 fn encode_topic(
353 rust: &Self::RustType,
354 ) -> alloy_sol_types::abi::token::WordToken {
355 <alloy::sol_types::sol_data::Uint<
356 56,
357 > as alloy_sol_types::EventTopic>::encode_topic(rust)
358 }
359 }
360 };
361 #[derive(serde::Serialize, serde::Deserialize)]
362 #[derive(Default, Debug, PartialEq, Eq, Hash)]
363 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
368 #[derive(Clone)]
369 pub struct WinProbMustNotBeSame;
370 #[allow(
371 non_camel_case_types,
372 non_snake_case,
373 clippy::pub_underscore_fields,
374 clippy::style
375 )]
376 const _: () = {
377 use alloy::sol_types as alloy_sol_types;
378 #[doc(hidden)]
379 type UnderlyingSolTuple<'a> = ();
380 #[doc(hidden)]
381 type UnderlyingRustTuple<'a> = ();
382 #[cfg(test)]
383 #[allow(dead_code, unreachable_patterns)]
384 fn _type_assertion(
385 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
386 ) {
387 match _t {
388 alloy_sol_types::private::AssertTypeEq::<
389 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
390 >(_) => {}
391 }
392 }
393 #[automatically_derived]
394 #[doc(hidden)]
395 impl ::core::convert::From<WinProbMustNotBeSame> for UnderlyingRustTuple<'_> {
396 fn from(value: WinProbMustNotBeSame) -> Self {
397 ()
398 }
399 }
400 #[automatically_derived]
401 #[doc(hidden)]
402 impl ::core::convert::From<UnderlyingRustTuple<'_>> for WinProbMustNotBeSame {
403 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
404 Self
405 }
406 }
407 #[automatically_derived]
408 impl alloy_sol_types::SolError for WinProbMustNotBeSame {
409 type Parameters<'a> = UnderlyingSolTuple<'a>;
410 type Token<'a> = <Self::Parameters<
411 'a,
412 > as alloy_sol_types::SolType>::Token<'a>;
413 const SIGNATURE: &'static str = "WinProbMustNotBeSame()";
414 const SELECTOR: [u8; 4] = [54u8, 191u8, 31u8, 205u8];
415 #[inline]
416 fn new<'a>(
417 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
418 ) -> Self {
419 tuple.into()
420 }
421 #[inline]
422 fn tokenize(&self) -> Self::Token<'_> {
423 ()
424 }
425 #[inline]
426 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
427 <Self::Parameters<
428 '_,
429 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
430 .map(Self::new)
431 }
432 }
433 };
434 #[derive(serde::Serialize, serde::Deserialize)]
435 #[derive(Default, Debug, PartialEq, Eq, Hash)]
436 #[allow(
441 non_camel_case_types,
442 non_snake_case,
443 clippy::pub_underscore_fields,
444 clippy::style
445 )]
446 #[derive(Clone)]
447 pub struct OwnershipTransferStarted {
448 #[allow(missing_docs)]
449 pub previousOwner: alloy::sol_types::private::Address,
450 #[allow(missing_docs)]
451 pub newOwner: alloy::sol_types::private::Address,
452 }
453 #[allow(
454 non_camel_case_types,
455 non_snake_case,
456 clippy::pub_underscore_fields,
457 clippy::style
458 )]
459 const _: () = {
460 use alloy::sol_types as alloy_sol_types;
461 #[automatically_derived]
462 impl alloy_sol_types::SolEvent for OwnershipTransferStarted {
463 type DataTuple<'a> = ();
464 type DataToken<'a> = <Self::DataTuple<
465 'a,
466 > as alloy_sol_types::SolType>::Token<'a>;
467 type TopicList = (
468 alloy_sol_types::sol_data::FixedBytes<32>,
469 alloy::sol_types::sol_data::Address,
470 alloy::sol_types::sol_data::Address,
471 );
472 const SIGNATURE: &'static str = "OwnershipTransferStarted(address,address)";
473 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
474 56u8, 209u8, 107u8, 140u8, 172u8, 34u8, 217u8, 159u8, 199u8, 193u8, 36u8,
475 185u8, 205u8, 13u8, 226u8, 211u8, 250u8, 31u8, 174u8, 244u8, 32u8, 191u8,
476 231u8, 145u8, 216u8, 195u8, 98u8, 215u8, 101u8, 226u8, 39u8, 0u8,
477 ]);
478 const ANONYMOUS: bool = false;
479 #[allow(unused_variables)]
480 #[inline]
481 fn new(
482 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
483 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
484 ) -> Self {
485 Self {
486 previousOwner: topics.1,
487 newOwner: topics.2,
488 }
489 }
490 #[inline]
491 fn check_signature(
492 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
493 ) -> alloy_sol_types::Result<()> {
494 if topics.0 != Self::SIGNATURE_HASH {
495 return Err(
496 alloy_sol_types::Error::invalid_event_signature_hash(
497 Self::SIGNATURE,
498 topics.0,
499 Self::SIGNATURE_HASH,
500 ),
501 );
502 }
503 Ok(())
504 }
505 #[inline]
506 fn tokenize_body(&self) -> Self::DataToken<'_> {
507 ()
508 }
509 #[inline]
510 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
511 (
512 Self::SIGNATURE_HASH.into(),
513 self.previousOwner.clone(),
514 self.newOwner.clone(),
515 )
516 }
517 #[inline]
518 fn encode_topics_raw(
519 &self,
520 out: &mut [alloy_sol_types::abi::token::WordToken],
521 ) -> alloy_sol_types::Result<()> {
522 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
523 return Err(alloy_sol_types::Error::Overrun);
524 }
525 out[0usize] = alloy_sol_types::abi::token::WordToken(
526 Self::SIGNATURE_HASH,
527 );
528 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
529 &self.previousOwner,
530 );
531 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
532 &self.newOwner,
533 );
534 Ok(())
535 }
536 }
537 #[automatically_derived]
538 impl alloy_sol_types::private::IntoLogData for OwnershipTransferStarted {
539 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
540 From::from(self)
541 }
542 fn into_log_data(self) -> alloy_sol_types::private::LogData {
543 From::from(&self)
544 }
545 }
546 #[automatically_derived]
547 impl From<&OwnershipTransferStarted> for alloy_sol_types::private::LogData {
548 #[inline]
549 fn from(
550 this: &OwnershipTransferStarted,
551 ) -> alloy_sol_types::private::LogData {
552 alloy_sol_types::SolEvent::encode_log_data(this)
553 }
554 }
555 };
556 #[derive(serde::Serialize, serde::Deserialize)]
557 #[derive(Default, Debug, PartialEq, Eq, Hash)]
558 #[allow(
563 non_camel_case_types,
564 non_snake_case,
565 clippy::pub_underscore_fields,
566 clippy::style
567 )]
568 #[derive(Clone)]
569 pub struct OwnershipTransferred {
570 #[allow(missing_docs)]
571 pub previousOwner: alloy::sol_types::private::Address,
572 #[allow(missing_docs)]
573 pub newOwner: alloy::sol_types::private::Address,
574 }
575 #[allow(
576 non_camel_case_types,
577 non_snake_case,
578 clippy::pub_underscore_fields,
579 clippy::style
580 )]
581 const _: () = {
582 use alloy::sol_types as alloy_sol_types;
583 #[automatically_derived]
584 impl alloy_sol_types::SolEvent for OwnershipTransferred {
585 type DataTuple<'a> = ();
586 type DataToken<'a> = <Self::DataTuple<
587 'a,
588 > as alloy_sol_types::SolType>::Token<'a>;
589 type TopicList = (
590 alloy_sol_types::sol_data::FixedBytes<32>,
591 alloy::sol_types::sol_data::Address,
592 alloy::sol_types::sol_data::Address,
593 );
594 const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
595 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
596 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
597 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
598 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
599 ]);
600 const ANONYMOUS: bool = false;
601 #[allow(unused_variables)]
602 #[inline]
603 fn new(
604 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
605 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
606 ) -> Self {
607 Self {
608 previousOwner: topics.1,
609 newOwner: topics.2,
610 }
611 }
612 #[inline]
613 fn check_signature(
614 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
615 ) -> alloy_sol_types::Result<()> {
616 if topics.0 != Self::SIGNATURE_HASH {
617 return Err(
618 alloy_sol_types::Error::invalid_event_signature_hash(
619 Self::SIGNATURE,
620 topics.0,
621 Self::SIGNATURE_HASH,
622 ),
623 );
624 }
625 Ok(())
626 }
627 #[inline]
628 fn tokenize_body(&self) -> Self::DataToken<'_> {
629 ()
630 }
631 #[inline]
632 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
633 (
634 Self::SIGNATURE_HASH.into(),
635 self.previousOwner.clone(),
636 self.newOwner.clone(),
637 )
638 }
639 #[inline]
640 fn encode_topics_raw(
641 &self,
642 out: &mut [alloy_sol_types::abi::token::WordToken],
643 ) -> alloy_sol_types::Result<()> {
644 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
645 return Err(alloy_sol_types::Error::Overrun);
646 }
647 out[0usize] = alloy_sol_types::abi::token::WordToken(
648 Self::SIGNATURE_HASH,
649 );
650 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
651 &self.previousOwner,
652 );
653 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
654 &self.newOwner,
655 );
656 Ok(())
657 }
658 }
659 #[automatically_derived]
660 impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
661 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
662 From::from(self)
663 }
664 fn into_log_data(self) -> alloy_sol_types::private::LogData {
665 From::from(&self)
666 }
667 }
668 #[automatically_derived]
669 impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
670 #[inline]
671 fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
672 alloy_sol_types::SolEvent::encode_log_data(this)
673 }
674 }
675 };
676 #[derive(serde::Serialize, serde::Deserialize)]
677 #[derive(Default, Debug, PartialEq, Eq, Hash)]
678 #[allow(
683 non_camel_case_types,
684 non_snake_case,
685 clippy::pub_underscore_fields,
686 clippy::style
687 )]
688 #[derive(Clone)]
689 pub struct WinProbUpdated {
690 #[allow(missing_docs)]
691 pub oldWinProb: <WinProb as alloy::sol_types::SolType>::RustType,
692 #[allow(missing_docs)]
693 pub newWinProb: <WinProb as alloy::sol_types::SolType>::RustType,
694 }
695 #[allow(
696 non_camel_case_types,
697 non_snake_case,
698 clippy::pub_underscore_fields,
699 clippy::style
700 )]
701 const _: () = {
702 use alloy::sol_types as alloy_sol_types;
703 #[automatically_derived]
704 impl alloy_sol_types::SolEvent for WinProbUpdated {
705 type DataTuple<'a> = (WinProb, WinProb);
706 type DataToken<'a> = <Self::DataTuple<
707 'a,
708 > as alloy_sol_types::SolType>::Token<'a>;
709 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
710 const SIGNATURE: &'static str = "WinProbUpdated(uint56,uint56)";
711 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
712 2u8, 114u8, 140u8, 74u8, 128u8, 55u8, 63u8, 71u8, 101u8, 85u8, 157u8,
713 195u8, 160u8, 70u8, 237u8, 234u8, 136u8, 24u8, 100u8, 36u8, 130u8, 114u8,
714 56u8, 187u8, 70u8, 36u8, 86u8, 104u8, 49u8, 93u8, 56u8, 0u8,
715 ]);
716 const ANONYMOUS: bool = false;
717 #[allow(unused_variables)]
718 #[inline]
719 fn new(
720 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
721 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
722 ) -> Self {
723 Self {
724 oldWinProb: data.0,
725 newWinProb: data.1,
726 }
727 }
728 #[inline]
729 fn check_signature(
730 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
731 ) -> alloy_sol_types::Result<()> {
732 if topics.0 != Self::SIGNATURE_HASH {
733 return Err(
734 alloy_sol_types::Error::invalid_event_signature_hash(
735 Self::SIGNATURE,
736 topics.0,
737 Self::SIGNATURE_HASH,
738 ),
739 );
740 }
741 Ok(())
742 }
743 #[inline]
744 fn tokenize_body(&self) -> Self::DataToken<'_> {
745 (
746 <WinProb as alloy_sol_types::SolType>::tokenize(&self.oldWinProb),
747 <WinProb as alloy_sol_types::SolType>::tokenize(&self.newWinProb),
748 )
749 }
750 #[inline]
751 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
752 (Self::SIGNATURE_HASH.into(),)
753 }
754 #[inline]
755 fn encode_topics_raw(
756 &self,
757 out: &mut [alloy_sol_types::abi::token::WordToken],
758 ) -> alloy_sol_types::Result<()> {
759 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
760 return Err(alloy_sol_types::Error::Overrun);
761 }
762 out[0usize] = alloy_sol_types::abi::token::WordToken(
763 Self::SIGNATURE_HASH,
764 );
765 Ok(())
766 }
767 }
768 #[automatically_derived]
769 impl alloy_sol_types::private::IntoLogData for WinProbUpdated {
770 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
771 From::from(self)
772 }
773 fn into_log_data(self) -> alloy_sol_types::private::LogData {
774 From::from(&self)
775 }
776 }
777 #[automatically_derived]
778 impl From<&WinProbUpdated> for alloy_sol_types::private::LogData {
779 #[inline]
780 fn from(this: &WinProbUpdated) -> alloy_sol_types::private::LogData {
781 alloy_sol_types::SolEvent::encode_log_data(this)
782 }
783 }
784 };
785 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
790 #[derive(Clone)]
791 pub struct constructorCall {
792 #[allow(missing_docs)]
793 pub _newOwner: alloy::sol_types::private::Address,
794 #[allow(missing_docs)]
795 pub _initialWinProb: <WinProb as alloy::sol_types::SolType>::RustType,
796 }
797 const _: () = {
798 use alloy::sol_types as alloy_sol_types;
799 {
800 #[doc(hidden)]
801 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address, WinProb);
802 #[doc(hidden)]
803 type UnderlyingRustTuple<'a> = (
804 alloy::sol_types::private::Address,
805 <WinProb as alloy::sol_types::SolType>::RustType,
806 );
807 #[cfg(test)]
808 #[allow(dead_code, unreachable_patterns)]
809 fn _type_assertion(
810 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
811 ) {
812 match _t {
813 alloy_sol_types::private::AssertTypeEq::<
814 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
815 >(_) => {}
816 }
817 }
818 #[automatically_derived]
819 #[doc(hidden)]
820 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
821 fn from(value: constructorCall) -> Self {
822 (value._newOwner, value._initialWinProb)
823 }
824 }
825 #[automatically_derived]
826 #[doc(hidden)]
827 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
828 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
829 Self {
830 _newOwner: tuple.0,
831 _initialWinProb: tuple.1,
832 }
833 }
834 }
835 }
836 #[automatically_derived]
837 impl alloy_sol_types::SolConstructor for constructorCall {
838 type Parameters<'a> = (alloy::sol_types::sol_data::Address, WinProb);
839 type Token<'a> = <Self::Parameters<
840 'a,
841 > as alloy_sol_types::SolType>::Token<'a>;
842 #[inline]
843 fn new<'a>(
844 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
845 ) -> Self {
846 tuple.into()
847 }
848 #[inline]
849 fn tokenize(&self) -> Self::Token<'_> {
850 (
851 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
852 &self._newOwner,
853 ),
854 <WinProb as alloy_sol_types::SolType>::tokenize(
855 &self._initialWinProb,
856 ),
857 )
858 }
859 }
860 };
861 #[derive(serde::Serialize, serde::Deserialize)]
862 #[derive(Default, Debug, PartialEq, Eq, Hash)]
863 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
868 #[derive(Clone)]
869 pub struct acceptOwnershipCall;
870 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
872 #[derive(Clone)]
873 pub struct acceptOwnershipReturn {}
874 #[allow(
875 non_camel_case_types,
876 non_snake_case,
877 clippy::pub_underscore_fields,
878 clippy::style
879 )]
880 const _: () = {
881 use alloy::sol_types as alloy_sol_types;
882 {
883 #[doc(hidden)]
884 type UnderlyingSolTuple<'a> = ();
885 #[doc(hidden)]
886 type UnderlyingRustTuple<'a> = ();
887 #[cfg(test)]
888 #[allow(dead_code, unreachable_patterns)]
889 fn _type_assertion(
890 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
891 ) {
892 match _t {
893 alloy_sol_types::private::AssertTypeEq::<
894 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
895 >(_) => {}
896 }
897 }
898 #[automatically_derived]
899 #[doc(hidden)]
900 impl ::core::convert::From<acceptOwnershipCall> for UnderlyingRustTuple<'_> {
901 fn from(value: acceptOwnershipCall) -> Self {
902 ()
903 }
904 }
905 #[automatically_derived]
906 #[doc(hidden)]
907 impl ::core::convert::From<UnderlyingRustTuple<'_>> for acceptOwnershipCall {
908 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
909 Self
910 }
911 }
912 }
913 {
914 #[doc(hidden)]
915 type UnderlyingSolTuple<'a> = ();
916 #[doc(hidden)]
917 type UnderlyingRustTuple<'a> = ();
918 #[cfg(test)]
919 #[allow(dead_code, unreachable_patterns)]
920 fn _type_assertion(
921 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
922 ) {
923 match _t {
924 alloy_sol_types::private::AssertTypeEq::<
925 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
926 >(_) => {}
927 }
928 }
929 #[automatically_derived]
930 #[doc(hidden)]
931 impl ::core::convert::From<acceptOwnershipReturn>
932 for UnderlyingRustTuple<'_> {
933 fn from(value: acceptOwnershipReturn) -> Self {
934 ()
935 }
936 }
937 #[automatically_derived]
938 #[doc(hidden)]
939 impl ::core::convert::From<UnderlyingRustTuple<'_>>
940 for acceptOwnershipReturn {
941 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
942 Self {}
943 }
944 }
945 }
946 impl acceptOwnershipReturn {
947 fn _tokenize(
948 &self,
949 ) -> <acceptOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
950 ()
951 }
952 }
953 #[automatically_derived]
954 impl alloy_sol_types::SolCall for acceptOwnershipCall {
955 type Parameters<'a> = ();
956 type Token<'a> = <Self::Parameters<
957 'a,
958 > as alloy_sol_types::SolType>::Token<'a>;
959 type Return = acceptOwnershipReturn;
960 type ReturnTuple<'a> = ();
961 type ReturnToken<'a> = <Self::ReturnTuple<
962 'a,
963 > as alloy_sol_types::SolType>::Token<'a>;
964 const SIGNATURE: &'static str = "acceptOwnership()";
965 const SELECTOR: [u8; 4] = [121u8, 186u8, 80u8, 151u8];
966 #[inline]
967 fn new<'a>(
968 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
969 ) -> Self {
970 tuple.into()
971 }
972 #[inline]
973 fn tokenize(&self) -> Self::Token<'_> {
974 ()
975 }
976 #[inline]
977 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
978 acceptOwnershipReturn::_tokenize(ret)
979 }
980 #[inline]
981 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
982 <Self::ReturnTuple<
983 '_,
984 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
985 .map(Into::into)
986 }
987 #[inline]
988 fn abi_decode_returns_validate(
989 data: &[u8],
990 ) -> alloy_sol_types::Result<Self::Return> {
991 <Self::ReturnTuple<
992 '_,
993 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
994 .map(Into::into)
995 }
996 }
997 };
998 #[derive(serde::Serialize, serde::Deserialize)]
999 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1000 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1005 #[derive(Clone)]
1006 pub struct currentWinProbCall;
1007 #[derive(serde::Serialize, serde::Deserialize)]
1008 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1009 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1011 #[derive(Clone)]
1012 pub struct currentWinProbReturn {
1013 #[allow(missing_docs)]
1014 pub _0: <WinProb as alloy::sol_types::SolType>::RustType,
1015 }
1016 #[allow(
1017 non_camel_case_types,
1018 non_snake_case,
1019 clippy::pub_underscore_fields,
1020 clippy::style
1021 )]
1022 const _: () = {
1023 use alloy::sol_types as alloy_sol_types;
1024 {
1025 #[doc(hidden)]
1026 type UnderlyingSolTuple<'a> = ();
1027 #[doc(hidden)]
1028 type UnderlyingRustTuple<'a> = ();
1029 #[cfg(test)]
1030 #[allow(dead_code, unreachable_patterns)]
1031 fn _type_assertion(
1032 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1033 ) {
1034 match _t {
1035 alloy_sol_types::private::AssertTypeEq::<
1036 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1037 >(_) => {}
1038 }
1039 }
1040 #[automatically_derived]
1041 #[doc(hidden)]
1042 impl ::core::convert::From<currentWinProbCall> for UnderlyingRustTuple<'_> {
1043 fn from(value: currentWinProbCall) -> Self {
1044 ()
1045 }
1046 }
1047 #[automatically_derived]
1048 #[doc(hidden)]
1049 impl ::core::convert::From<UnderlyingRustTuple<'_>> for currentWinProbCall {
1050 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1051 Self
1052 }
1053 }
1054 }
1055 {
1056 #[doc(hidden)]
1057 type UnderlyingSolTuple<'a> = (WinProb,);
1058 #[doc(hidden)]
1059 type UnderlyingRustTuple<'a> = (
1060 <WinProb as alloy::sol_types::SolType>::RustType,
1061 );
1062 #[cfg(test)]
1063 #[allow(dead_code, unreachable_patterns)]
1064 fn _type_assertion(
1065 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1066 ) {
1067 match _t {
1068 alloy_sol_types::private::AssertTypeEq::<
1069 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1070 >(_) => {}
1071 }
1072 }
1073 #[automatically_derived]
1074 #[doc(hidden)]
1075 impl ::core::convert::From<currentWinProbReturn>
1076 for UnderlyingRustTuple<'_> {
1077 fn from(value: currentWinProbReturn) -> Self {
1078 (value._0,)
1079 }
1080 }
1081 #[automatically_derived]
1082 #[doc(hidden)]
1083 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1084 for currentWinProbReturn {
1085 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1086 Self { _0: tuple.0 }
1087 }
1088 }
1089 }
1090 #[automatically_derived]
1091 impl alloy_sol_types::SolCall for currentWinProbCall {
1092 type Parameters<'a> = ();
1093 type Token<'a> = <Self::Parameters<
1094 'a,
1095 > as alloy_sol_types::SolType>::Token<'a>;
1096 type Return = <WinProb as alloy::sol_types::SolType>::RustType;
1097 type ReturnTuple<'a> = (WinProb,);
1098 type ReturnToken<'a> = <Self::ReturnTuple<
1099 'a,
1100 > as alloy_sol_types::SolType>::Token<'a>;
1101 const SIGNATURE: &'static str = "currentWinProb()";
1102 const SELECTOR: [u8; 4] = [22u8, 142u8, 145u8, 96u8];
1103 #[inline]
1104 fn new<'a>(
1105 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1106 ) -> Self {
1107 tuple.into()
1108 }
1109 #[inline]
1110 fn tokenize(&self) -> Self::Token<'_> {
1111 ()
1112 }
1113 #[inline]
1114 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1115 (<WinProb as alloy_sol_types::SolType>::tokenize(ret),)
1116 }
1117 #[inline]
1118 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1119 <Self::ReturnTuple<
1120 '_,
1121 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1122 .map(|r| {
1123 let r: currentWinProbReturn = r.into();
1124 r._0
1125 })
1126 }
1127 #[inline]
1128 fn abi_decode_returns_validate(
1129 data: &[u8],
1130 ) -> alloy_sol_types::Result<Self::Return> {
1131 <Self::ReturnTuple<
1132 '_,
1133 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1134 .map(|r| {
1135 let r: currentWinProbReturn = r.into();
1136 r._0
1137 })
1138 }
1139 }
1140 };
1141 #[derive(serde::Serialize, serde::Deserialize)]
1142 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1143 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1148 #[derive(Clone)]
1149 pub struct ownerCall;
1150 #[derive(serde::Serialize, serde::Deserialize)]
1151 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1152 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1154 #[derive(Clone)]
1155 pub struct ownerReturn {
1156 #[allow(missing_docs)]
1157 pub _0: alloy::sol_types::private::Address,
1158 }
1159 #[allow(
1160 non_camel_case_types,
1161 non_snake_case,
1162 clippy::pub_underscore_fields,
1163 clippy::style
1164 )]
1165 const _: () = {
1166 use alloy::sol_types as alloy_sol_types;
1167 {
1168 #[doc(hidden)]
1169 type UnderlyingSolTuple<'a> = ();
1170 #[doc(hidden)]
1171 type UnderlyingRustTuple<'a> = ();
1172 #[cfg(test)]
1173 #[allow(dead_code, unreachable_patterns)]
1174 fn _type_assertion(
1175 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1176 ) {
1177 match _t {
1178 alloy_sol_types::private::AssertTypeEq::<
1179 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1180 >(_) => {}
1181 }
1182 }
1183 #[automatically_derived]
1184 #[doc(hidden)]
1185 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
1186 fn from(value: ownerCall) -> Self {
1187 ()
1188 }
1189 }
1190 #[automatically_derived]
1191 #[doc(hidden)]
1192 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
1193 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1194 Self
1195 }
1196 }
1197 }
1198 {
1199 #[doc(hidden)]
1200 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1201 #[doc(hidden)]
1202 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1203 #[cfg(test)]
1204 #[allow(dead_code, unreachable_patterns)]
1205 fn _type_assertion(
1206 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1207 ) {
1208 match _t {
1209 alloy_sol_types::private::AssertTypeEq::<
1210 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1211 >(_) => {}
1212 }
1213 }
1214 #[automatically_derived]
1215 #[doc(hidden)]
1216 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
1217 fn from(value: ownerReturn) -> Self {
1218 (value._0,)
1219 }
1220 }
1221 #[automatically_derived]
1222 #[doc(hidden)]
1223 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
1224 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1225 Self { _0: tuple.0 }
1226 }
1227 }
1228 }
1229 #[automatically_derived]
1230 impl alloy_sol_types::SolCall for ownerCall {
1231 type Parameters<'a> = ();
1232 type Token<'a> = <Self::Parameters<
1233 'a,
1234 > as alloy_sol_types::SolType>::Token<'a>;
1235 type Return = alloy::sol_types::private::Address;
1236 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1237 type ReturnToken<'a> = <Self::ReturnTuple<
1238 'a,
1239 > as alloy_sol_types::SolType>::Token<'a>;
1240 const SIGNATURE: &'static str = "owner()";
1241 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
1242 #[inline]
1243 fn new<'a>(
1244 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1245 ) -> Self {
1246 tuple.into()
1247 }
1248 #[inline]
1249 fn tokenize(&self) -> Self::Token<'_> {
1250 ()
1251 }
1252 #[inline]
1253 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1254 (
1255 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1256 ret,
1257 ),
1258 )
1259 }
1260 #[inline]
1261 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1262 <Self::ReturnTuple<
1263 '_,
1264 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1265 .map(|r| {
1266 let r: ownerReturn = r.into();
1267 r._0
1268 })
1269 }
1270 #[inline]
1271 fn abi_decode_returns_validate(
1272 data: &[u8],
1273 ) -> alloy_sol_types::Result<Self::Return> {
1274 <Self::ReturnTuple<
1275 '_,
1276 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1277 .map(|r| {
1278 let r: ownerReturn = r.into();
1279 r._0
1280 })
1281 }
1282 }
1283 };
1284 #[derive(serde::Serialize, serde::Deserialize)]
1285 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1286 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1291 #[derive(Clone)]
1292 pub struct pendingOwnerCall;
1293 #[derive(serde::Serialize, serde::Deserialize)]
1294 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1295 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1297 #[derive(Clone)]
1298 pub struct pendingOwnerReturn {
1299 #[allow(missing_docs)]
1300 pub _0: alloy::sol_types::private::Address,
1301 }
1302 #[allow(
1303 non_camel_case_types,
1304 non_snake_case,
1305 clippy::pub_underscore_fields,
1306 clippy::style
1307 )]
1308 const _: () = {
1309 use alloy::sol_types as alloy_sol_types;
1310 {
1311 #[doc(hidden)]
1312 type UnderlyingSolTuple<'a> = ();
1313 #[doc(hidden)]
1314 type UnderlyingRustTuple<'a> = ();
1315 #[cfg(test)]
1316 #[allow(dead_code, unreachable_patterns)]
1317 fn _type_assertion(
1318 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1319 ) {
1320 match _t {
1321 alloy_sol_types::private::AssertTypeEq::<
1322 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1323 >(_) => {}
1324 }
1325 }
1326 #[automatically_derived]
1327 #[doc(hidden)]
1328 impl ::core::convert::From<pendingOwnerCall> for UnderlyingRustTuple<'_> {
1329 fn from(value: pendingOwnerCall) -> Self {
1330 ()
1331 }
1332 }
1333 #[automatically_derived]
1334 #[doc(hidden)]
1335 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pendingOwnerCall {
1336 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1337 Self
1338 }
1339 }
1340 }
1341 {
1342 #[doc(hidden)]
1343 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1344 #[doc(hidden)]
1345 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1346 #[cfg(test)]
1347 #[allow(dead_code, unreachable_patterns)]
1348 fn _type_assertion(
1349 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1350 ) {
1351 match _t {
1352 alloy_sol_types::private::AssertTypeEq::<
1353 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1354 >(_) => {}
1355 }
1356 }
1357 #[automatically_derived]
1358 #[doc(hidden)]
1359 impl ::core::convert::From<pendingOwnerReturn> for UnderlyingRustTuple<'_> {
1360 fn from(value: pendingOwnerReturn) -> Self {
1361 (value._0,)
1362 }
1363 }
1364 #[automatically_derived]
1365 #[doc(hidden)]
1366 impl ::core::convert::From<UnderlyingRustTuple<'_>> for pendingOwnerReturn {
1367 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1368 Self { _0: tuple.0 }
1369 }
1370 }
1371 }
1372 #[automatically_derived]
1373 impl alloy_sol_types::SolCall for pendingOwnerCall {
1374 type Parameters<'a> = ();
1375 type Token<'a> = <Self::Parameters<
1376 'a,
1377 > as alloy_sol_types::SolType>::Token<'a>;
1378 type Return = alloy::sol_types::private::Address;
1379 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1380 type ReturnToken<'a> = <Self::ReturnTuple<
1381 'a,
1382 > as alloy_sol_types::SolType>::Token<'a>;
1383 const SIGNATURE: &'static str = "pendingOwner()";
1384 const SELECTOR: [u8; 4] = [227u8, 12u8, 57u8, 120u8];
1385 #[inline]
1386 fn new<'a>(
1387 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1388 ) -> Self {
1389 tuple.into()
1390 }
1391 #[inline]
1392 fn tokenize(&self) -> Self::Token<'_> {
1393 ()
1394 }
1395 #[inline]
1396 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1397 (
1398 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1399 ret,
1400 ),
1401 )
1402 }
1403 #[inline]
1404 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1405 <Self::ReturnTuple<
1406 '_,
1407 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1408 .map(|r| {
1409 let r: pendingOwnerReturn = r.into();
1410 r._0
1411 })
1412 }
1413 #[inline]
1414 fn abi_decode_returns_validate(
1415 data: &[u8],
1416 ) -> alloy_sol_types::Result<Self::Return> {
1417 <Self::ReturnTuple<
1418 '_,
1419 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1420 .map(|r| {
1421 let r: pendingOwnerReturn = r.into();
1422 r._0
1423 })
1424 }
1425 }
1426 };
1427 #[derive(serde::Serialize, serde::Deserialize)]
1428 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1429 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1434 #[derive(Clone)]
1435 pub struct renounceOwnershipCall;
1436 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1438 #[derive(Clone)]
1439 pub struct renounceOwnershipReturn {}
1440 #[allow(
1441 non_camel_case_types,
1442 non_snake_case,
1443 clippy::pub_underscore_fields,
1444 clippy::style
1445 )]
1446 const _: () = {
1447 use alloy::sol_types as alloy_sol_types;
1448 {
1449 #[doc(hidden)]
1450 type UnderlyingSolTuple<'a> = ();
1451 #[doc(hidden)]
1452 type UnderlyingRustTuple<'a> = ();
1453 #[cfg(test)]
1454 #[allow(dead_code, unreachable_patterns)]
1455 fn _type_assertion(
1456 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1457 ) {
1458 match _t {
1459 alloy_sol_types::private::AssertTypeEq::<
1460 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1461 >(_) => {}
1462 }
1463 }
1464 #[automatically_derived]
1465 #[doc(hidden)]
1466 impl ::core::convert::From<renounceOwnershipCall>
1467 for UnderlyingRustTuple<'_> {
1468 fn from(value: renounceOwnershipCall) -> Self {
1469 ()
1470 }
1471 }
1472 #[automatically_derived]
1473 #[doc(hidden)]
1474 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1475 for renounceOwnershipCall {
1476 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1477 Self
1478 }
1479 }
1480 }
1481 {
1482 #[doc(hidden)]
1483 type UnderlyingSolTuple<'a> = ();
1484 #[doc(hidden)]
1485 type UnderlyingRustTuple<'a> = ();
1486 #[cfg(test)]
1487 #[allow(dead_code, unreachable_patterns)]
1488 fn _type_assertion(
1489 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1490 ) {
1491 match _t {
1492 alloy_sol_types::private::AssertTypeEq::<
1493 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1494 >(_) => {}
1495 }
1496 }
1497 #[automatically_derived]
1498 #[doc(hidden)]
1499 impl ::core::convert::From<renounceOwnershipReturn>
1500 for UnderlyingRustTuple<'_> {
1501 fn from(value: renounceOwnershipReturn) -> Self {
1502 ()
1503 }
1504 }
1505 #[automatically_derived]
1506 #[doc(hidden)]
1507 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1508 for renounceOwnershipReturn {
1509 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1510 Self {}
1511 }
1512 }
1513 }
1514 impl renounceOwnershipReturn {
1515 fn _tokenize(
1516 &self,
1517 ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1518 ()
1519 }
1520 }
1521 #[automatically_derived]
1522 impl alloy_sol_types::SolCall for renounceOwnershipCall {
1523 type Parameters<'a> = ();
1524 type Token<'a> = <Self::Parameters<
1525 'a,
1526 > as alloy_sol_types::SolType>::Token<'a>;
1527 type Return = renounceOwnershipReturn;
1528 type ReturnTuple<'a> = ();
1529 type ReturnToken<'a> = <Self::ReturnTuple<
1530 'a,
1531 > as alloy_sol_types::SolType>::Token<'a>;
1532 const SIGNATURE: &'static str = "renounceOwnership()";
1533 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
1534 #[inline]
1535 fn new<'a>(
1536 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1537 ) -> Self {
1538 tuple.into()
1539 }
1540 #[inline]
1541 fn tokenize(&self) -> Self::Token<'_> {
1542 ()
1543 }
1544 #[inline]
1545 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1546 renounceOwnershipReturn::_tokenize(ret)
1547 }
1548 #[inline]
1549 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1550 <Self::ReturnTuple<
1551 '_,
1552 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1553 .map(Into::into)
1554 }
1555 #[inline]
1556 fn abi_decode_returns_validate(
1557 data: &[u8],
1558 ) -> alloy_sol_types::Result<Self::Return> {
1559 <Self::ReturnTuple<
1560 '_,
1561 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1562 .map(Into::into)
1563 }
1564 }
1565 };
1566 #[derive(serde::Serialize, serde::Deserialize)]
1567 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1568 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1573 #[derive(Clone)]
1574 pub struct setWinProbCall {
1575 #[allow(missing_docs)]
1576 pub _newWinProb: <WinProb as alloy::sol_types::SolType>::RustType,
1577 }
1578 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1580 #[derive(Clone)]
1581 pub struct setWinProbReturn {}
1582 #[allow(
1583 non_camel_case_types,
1584 non_snake_case,
1585 clippy::pub_underscore_fields,
1586 clippy::style
1587 )]
1588 const _: () = {
1589 use alloy::sol_types as alloy_sol_types;
1590 {
1591 #[doc(hidden)]
1592 type UnderlyingSolTuple<'a> = (WinProb,);
1593 #[doc(hidden)]
1594 type UnderlyingRustTuple<'a> = (
1595 <WinProb as alloy::sol_types::SolType>::RustType,
1596 );
1597 #[cfg(test)]
1598 #[allow(dead_code, unreachable_patterns)]
1599 fn _type_assertion(
1600 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1601 ) {
1602 match _t {
1603 alloy_sol_types::private::AssertTypeEq::<
1604 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1605 >(_) => {}
1606 }
1607 }
1608 #[automatically_derived]
1609 #[doc(hidden)]
1610 impl ::core::convert::From<setWinProbCall> for UnderlyingRustTuple<'_> {
1611 fn from(value: setWinProbCall) -> Self {
1612 (value._newWinProb,)
1613 }
1614 }
1615 #[automatically_derived]
1616 #[doc(hidden)]
1617 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setWinProbCall {
1618 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1619 Self { _newWinProb: tuple.0 }
1620 }
1621 }
1622 }
1623 {
1624 #[doc(hidden)]
1625 type UnderlyingSolTuple<'a> = ();
1626 #[doc(hidden)]
1627 type UnderlyingRustTuple<'a> = ();
1628 #[cfg(test)]
1629 #[allow(dead_code, unreachable_patterns)]
1630 fn _type_assertion(
1631 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1632 ) {
1633 match _t {
1634 alloy_sol_types::private::AssertTypeEq::<
1635 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1636 >(_) => {}
1637 }
1638 }
1639 #[automatically_derived]
1640 #[doc(hidden)]
1641 impl ::core::convert::From<setWinProbReturn> for UnderlyingRustTuple<'_> {
1642 fn from(value: setWinProbReturn) -> Self {
1643 ()
1644 }
1645 }
1646 #[automatically_derived]
1647 #[doc(hidden)]
1648 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setWinProbReturn {
1649 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1650 Self {}
1651 }
1652 }
1653 }
1654 impl setWinProbReturn {
1655 fn _tokenize(
1656 &self,
1657 ) -> <setWinProbCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1658 ()
1659 }
1660 }
1661 #[automatically_derived]
1662 impl alloy_sol_types::SolCall for setWinProbCall {
1663 type Parameters<'a> = (WinProb,);
1664 type Token<'a> = <Self::Parameters<
1665 'a,
1666 > as alloy_sol_types::SolType>::Token<'a>;
1667 type Return = setWinProbReturn;
1668 type ReturnTuple<'a> = ();
1669 type ReturnToken<'a> = <Self::ReturnTuple<
1670 'a,
1671 > as alloy_sol_types::SolType>::Token<'a>;
1672 const SIGNATURE: &'static str = "setWinProb(uint56)";
1673 const SELECTOR: [u8; 4] = [253u8, 228u8, 111u8, 248u8];
1674 #[inline]
1675 fn new<'a>(
1676 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1677 ) -> Self {
1678 tuple.into()
1679 }
1680 #[inline]
1681 fn tokenize(&self) -> Self::Token<'_> {
1682 (<WinProb as alloy_sol_types::SolType>::tokenize(&self._newWinProb),)
1683 }
1684 #[inline]
1685 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1686 setWinProbReturn::_tokenize(ret)
1687 }
1688 #[inline]
1689 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1690 <Self::ReturnTuple<
1691 '_,
1692 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1693 .map(Into::into)
1694 }
1695 #[inline]
1696 fn abi_decode_returns_validate(
1697 data: &[u8],
1698 ) -> alloy_sol_types::Result<Self::Return> {
1699 <Self::ReturnTuple<
1700 '_,
1701 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1702 .map(Into::into)
1703 }
1704 }
1705 };
1706 #[derive(serde::Serialize, serde::Deserialize)]
1707 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1708 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1713 #[derive(Clone)]
1714 pub struct transferOwnershipCall {
1715 #[allow(missing_docs)]
1716 pub newOwner: alloy::sol_types::private::Address,
1717 }
1718 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1720 #[derive(Clone)]
1721 pub struct transferOwnershipReturn {}
1722 #[allow(
1723 non_camel_case_types,
1724 non_snake_case,
1725 clippy::pub_underscore_fields,
1726 clippy::style
1727 )]
1728 const _: () = {
1729 use alloy::sol_types as alloy_sol_types;
1730 {
1731 #[doc(hidden)]
1732 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1733 #[doc(hidden)]
1734 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1735 #[cfg(test)]
1736 #[allow(dead_code, unreachable_patterns)]
1737 fn _type_assertion(
1738 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1739 ) {
1740 match _t {
1741 alloy_sol_types::private::AssertTypeEq::<
1742 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1743 >(_) => {}
1744 }
1745 }
1746 #[automatically_derived]
1747 #[doc(hidden)]
1748 impl ::core::convert::From<transferOwnershipCall>
1749 for UnderlyingRustTuple<'_> {
1750 fn from(value: transferOwnershipCall) -> Self {
1751 (value.newOwner,)
1752 }
1753 }
1754 #[automatically_derived]
1755 #[doc(hidden)]
1756 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1757 for transferOwnershipCall {
1758 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1759 Self { newOwner: tuple.0 }
1760 }
1761 }
1762 }
1763 {
1764 #[doc(hidden)]
1765 type UnderlyingSolTuple<'a> = ();
1766 #[doc(hidden)]
1767 type UnderlyingRustTuple<'a> = ();
1768 #[cfg(test)]
1769 #[allow(dead_code, unreachable_patterns)]
1770 fn _type_assertion(
1771 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1772 ) {
1773 match _t {
1774 alloy_sol_types::private::AssertTypeEq::<
1775 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1776 >(_) => {}
1777 }
1778 }
1779 #[automatically_derived]
1780 #[doc(hidden)]
1781 impl ::core::convert::From<transferOwnershipReturn>
1782 for UnderlyingRustTuple<'_> {
1783 fn from(value: transferOwnershipReturn) -> Self {
1784 ()
1785 }
1786 }
1787 #[automatically_derived]
1788 #[doc(hidden)]
1789 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1790 for transferOwnershipReturn {
1791 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1792 Self {}
1793 }
1794 }
1795 }
1796 impl transferOwnershipReturn {
1797 fn _tokenize(
1798 &self,
1799 ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1800 ()
1801 }
1802 }
1803 #[automatically_derived]
1804 impl alloy_sol_types::SolCall for transferOwnershipCall {
1805 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1806 type Token<'a> = <Self::Parameters<
1807 'a,
1808 > as alloy_sol_types::SolType>::Token<'a>;
1809 type Return = transferOwnershipReturn;
1810 type ReturnTuple<'a> = ();
1811 type ReturnToken<'a> = <Self::ReturnTuple<
1812 'a,
1813 > as alloy_sol_types::SolType>::Token<'a>;
1814 const SIGNATURE: &'static str = "transferOwnership(address)";
1815 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
1816 #[inline]
1817 fn new<'a>(
1818 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1819 ) -> Self {
1820 tuple.into()
1821 }
1822 #[inline]
1823 fn tokenize(&self) -> Self::Token<'_> {
1824 (
1825 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1826 &self.newOwner,
1827 ),
1828 )
1829 }
1830 #[inline]
1831 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1832 transferOwnershipReturn::_tokenize(ret)
1833 }
1834 #[inline]
1835 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1836 <Self::ReturnTuple<
1837 '_,
1838 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1839 .map(Into::into)
1840 }
1841 #[inline]
1842 fn abi_decode_returns_validate(
1843 data: &[u8],
1844 ) -> alloy_sol_types::Result<Self::Return> {
1845 <Self::ReturnTuple<
1846 '_,
1847 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1848 .map(Into::into)
1849 }
1850 }
1851 };
1852 #[derive(serde::Serialize, serde::Deserialize)]
1854 #[derive()]
1855 pub enum HoprWinningProbabilityOracleCalls {
1856 #[allow(missing_docs)]
1857 acceptOwnership(acceptOwnershipCall),
1858 #[allow(missing_docs)]
1859 currentWinProb(currentWinProbCall),
1860 #[allow(missing_docs)]
1861 owner(ownerCall),
1862 #[allow(missing_docs)]
1863 pendingOwner(pendingOwnerCall),
1864 #[allow(missing_docs)]
1865 renounceOwnership(renounceOwnershipCall),
1866 #[allow(missing_docs)]
1867 setWinProb(setWinProbCall),
1868 #[allow(missing_docs)]
1869 transferOwnership(transferOwnershipCall),
1870 }
1871 #[automatically_derived]
1872 impl HoprWinningProbabilityOracleCalls {
1873 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1880 [22u8, 142u8, 145u8, 96u8],
1881 [113u8, 80u8, 24u8, 166u8],
1882 [121u8, 186u8, 80u8, 151u8],
1883 [141u8, 165u8, 203u8, 91u8],
1884 [227u8, 12u8, 57u8, 120u8],
1885 [242u8, 253u8, 227u8, 139u8],
1886 [253u8, 228u8, 111u8, 248u8],
1887 ];
1888 }
1889 #[automatically_derived]
1890 impl alloy_sol_types::SolInterface for HoprWinningProbabilityOracleCalls {
1891 const NAME: &'static str = "HoprWinningProbabilityOracleCalls";
1892 const MIN_DATA_LENGTH: usize = 0usize;
1893 const COUNT: usize = 7usize;
1894 #[inline]
1895 fn selector(&self) -> [u8; 4] {
1896 match self {
1897 Self::acceptOwnership(_) => {
1898 <acceptOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1899 }
1900 Self::currentWinProb(_) => {
1901 <currentWinProbCall as alloy_sol_types::SolCall>::SELECTOR
1902 }
1903 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
1904 Self::pendingOwner(_) => {
1905 <pendingOwnerCall as alloy_sol_types::SolCall>::SELECTOR
1906 }
1907 Self::renounceOwnership(_) => {
1908 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1909 }
1910 Self::setWinProb(_) => {
1911 <setWinProbCall as alloy_sol_types::SolCall>::SELECTOR
1912 }
1913 Self::transferOwnership(_) => {
1914 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1915 }
1916 }
1917 }
1918 #[inline]
1919 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1920 Self::SELECTORS.get(i).copied()
1921 }
1922 #[inline]
1923 fn valid_selector(selector: [u8; 4]) -> bool {
1924 Self::SELECTORS.binary_search(&selector).is_ok()
1925 }
1926 #[inline]
1927 #[allow(non_snake_case)]
1928 fn abi_decode_raw(
1929 selector: [u8; 4],
1930 data: &[u8],
1931 ) -> alloy_sol_types::Result<Self> {
1932 static DECODE_SHIMS: &[fn(
1933 &[u8],
1934 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls>] = &[
1935 {
1936 fn currentWinProb(
1937 data: &[u8],
1938 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
1939 <currentWinProbCall as alloy_sol_types::SolCall>::abi_decode_raw(
1940 data,
1941 )
1942 .map(HoprWinningProbabilityOracleCalls::currentWinProb)
1943 }
1944 currentWinProb
1945 },
1946 {
1947 fn renounceOwnership(
1948 data: &[u8],
1949 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
1950 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
1951 data,
1952 )
1953 .map(HoprWinningProbabilityOracleCalls::renounceOwnership)
1954 }
1955 renounceOwnership
1956 },
1957 {
1958 fn acceptOwnership(
1959 data: &[u8],
1960 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
1961 <acceptOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
1962 data,
1963 )
1964 .map(HoprWinningProbabilityOracleCalls::acceptOwnership)
1965 }
1966 acceptOwnership
1967 },
1968 {
1969 fn owner(
1970 data: &[u8],
1971 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
1972 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
1973 .map(HoprWinningProbabilityOracleCalls::owner)
1974 }
1975 owner
1976 },
1977 {
1978 fn pendingOwner(
1979 data: &[u8],
1980 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
1981 <pendingOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw(
1982 data,
1983 )
1984 .map(HoprWinningProbabilityOracleCalls::pendingOwner)
1985 }
1986 pendingOwner
1987 },
1988 {
1989 fn transferOwnership(
1990 data: &[u8],
1991 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
1992 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
1993 data,
1994 )
1995 .map(HoprWinningProbabilityOracleCalls::transferOwnership)
1996 }
1997 transferOwnership
1998 },
1999 {
2000 fn setWinProb(
2001 data: &[u8],
2002 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
2003 <setWinProbCall as alloy_sol_types::SolCall>::abi_decode_raw(
2004 data,
2005 )
2006 .map(HoprWinningProbabilityOracleCalls::setWinProb)
2007 }
2008 setWinProb
2009 },
2010 ];
2011 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2012 return Err(
2013 alloy_sol_types::Error::unknown_selector(
2014 <Self as alloy_sol_types::SolInterface>::NAME,
2015 selector,
2016 ),
2017 );
2018 };
2019 DECODE_SHIMS[idx](data)
2020 }
2021 #[inline]
2022 #[allow(non_snake_case)]
2023 fn abi_decode_raw_validate(
2024 selector: [u8; 4],
2025 data: &[u8],
2026 ) -> alloy_sol_types::Result<Self> {
2027 static DECODE_VALIDATE_SHIMS: &[fn(
2028 &[u8],
2029 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls>] = &[
2030 {
2031 fn currentWinProb(
2032 data: &[u8],
2033 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
2034 <currentWinProbCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2035 data,
2036 )
2037 .map(HoprWinningProbabilityOracleCalls::currentWinProb)
2038 }
2039 currentWinProb
2040 },
2041 {
2042 fn renounceOwnership(
2043 data: &[u8],
2044 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
2045 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2046 data,
2047 )
2048 .map(HoprWinningProbabilityOracleCalls::renounceOwnership)
2049 }
2050 renounceOwnership
2051 },
2052 {
2053 fn acceptOwnership(
2054 data: &[u8],
2055 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
2056 <acceptOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2057 data,
2058 )
2059 .map(HoprWinningProbabilityOracleCalls::acceptOwnership)
2060 }
2061 acceptOwnership
2062 },
2063 {
2064 fn owner(
2065 data: &[u8],
2066 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
2067 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2068 data,
2069 )
2070 .map(HoprWinningProbabilityOracleCalls::owner)
2071 }
2072 owner
2073 },
2074 {
2075 fn pendingOwner(
2076 data: &[u8],
2077 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
2078 <pendingOwnerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2079 data,
2080 )
2081 .map(HoprWinningProbabilityOracleCalls::pendingOwner)
2082 }
2083 pendingOwner
2084 },
2085 {
2086 fn transferOwnership(
2087 data: &[u8],
2088 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
2089 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2090 data,
2091 )
2092 .map(HoprWinningProbabilityOracleCalls::transferOwnership)
2093 }
2094 transferOwnership
2095 },
2096 {
2097 fn setWinProb(
2098 data: &[u8],
2099 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleCalls> {
2100 <setWinProbCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
2101 data,
2102 )
2103 .map(HoprWinningProbabilityOracleCalls::setWinProb)
2104 }
2105 setWinProb
2106 },
2107 ];
2108 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2109 return Err(
2110 alloy_sol_types::Error::unknown_selector(
2111 <Self as alloy_sol_types::SolInterface>::NAME,
2112 selector,
2113 ),
2114 );
2115 };
2116 DECODE_VALIDATE_SHIMS[idx](data)
2117 }
2118 #[inline]
2119 fn abi_encoded_size(&self) -> usize {
2120 match self {
2121 Self::acceptOwnership(inner) => {
2122 <acceptOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
2123 inner,
2124 )
2125 }
2126 Self::currentWinProb(inner) => {
2127 <currentWinProbCall as alloy_sol_types::SolCall>::abi_encoded_size(
2128 inner,
2129 )
2130 }
2131 Self::owner(inner) => {
2132 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2133 }
2134 Self::pendingOwner(inner) => {
2135 <pendingOwnerCall as alloy_sol_types::SolCall>::abi_encoded_size(
2136 inner,
2137 )
2138 }
2139 Self::renounceOwnership(inner) => {
2140 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
2141 inner,
2142 )
2143 }
2144 Self::setWinProb(inner) => {
2145 <setWinProbCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
2146 }
2147 Self::transferOwnership(inner) => {
2148 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
2149 inner,
2150 )
2151 }
2152 }
2153 }
2154 #[inline]
2155 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2156 match self {
2157 Self::acceptOwnership(inner) => {
2158 <acceptOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
2159 inner,
2160 out,
2161 )
2162 }
2163 Self::currentWinProb(inner) => {
2164 <currentWinProbCall as alloy_sol_types::SolCall>::abi_encode_raw(
2165 inner,
2166 out,
2167 )
2168 }
2169 Self::owner(inner) => {
2170 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
2171 }
2172 Self::pendingOwner(inner) => {
2173 <pendingOwnerCall as alloy_sol_types::SolCall>::abi_encode_raw(
2174 inner,
2175 out,
2176 )
2177 }
2178 Self::renounceOwnership(inner) => {
2179 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
2180 inner,
2181 out,
2182 )
2183 }
2184 Self::setWinProb(inner) => {
2185 <setWinProbCall as alloy_sol_types::SolCall>::abi_encode_raw(
2186 inner,
2187 out,
2188 )
2189 }
2190 Self::transferOwnership(inner) => {
2191 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
2192 inner,
2193 out,
2194 )
2195 }
2196 }
2197 }
2198 }
2199 #[derive(serde::Serialize, serde::Deserialize)]
2201 #[derive(Debug, PartialEq, Eq, Hash)]
2202 pub enum HoprWinningProbabilityOracleErrors {
2203 #[allow(missing_docs)]
2204 WinProbMustNotBeSame(WinProbMustNotBeSame),
2205 }
2206 #[automatically_derived]
2207 impl HoprWinningProbabilityOracleErrors {
2208 pub const SELECTORS: &'static [[u8; 4usize]] = &[[54u8, 191u8, 31u8, 205u8]];
2215 }
2216 #[automatically_derived]
2217 impl alloy_sol_types::SolInterface for HoprWinningProbabilityOracleErrors {
2218 const NAME: &'static str = "HoprWinningProbabilityOracleErrors";
2219 const MIN_DATA_LENGTH: usize = 0usize;
2220 const COUNT: usize = 1usize;
2221 #[inline]
2222 fn selector(&self) -> [u8; 4] {
2223 match self {
2224 Self::WinProbMustNotBeSame(_) => {
2225 <WinProbMustNotBeSame as alloy_sol_types::SolError>::SELECTOR
2226 }
2227 }
2228 }
2229 #[inline]
2230 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2231 Self::SELECTORS.get(i).copied()
2232 }
2233 #[inline]
2234 fn valid_selector(selector: [u8; 4]) -> bool {
2235 Self::SELECTORS.binary_search(&selector).is_ok()
2236 }
2237 #[inline]
2238 #[allow(non_snake_case)]
2239 fn abi_decode_raw(
2240 selector: [u8; 4],
2241 data: &[u8],
2242 ) -> alloy_sol_types::Result<Self> {
2243 static DECODE_SHIMS: &[fn(
2244 &[u8],
2245 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleErrors>] = &[
2246 {
2247 fn WinProbMustNotBeSame(
2248 data: &[u8],
2249 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleErrors> {
2250 <WinProbMustNotBeSame as alloy_sol_types::SolError>::abi_decode_raw(
2251 data,
2252 )
2253 .map(
2254 HoprWinningProbabilityOracleErrors::WinProbMustNotBeSame,
2255 )
2256 }
2257 WinProbMustNotBeSame
2258 },
2259 ];
2260 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2261 return Err(
2262 alloy_sol_types::Error::unknown_selector(
2263 <Self as alloy_sol_types::SolInterface>::NAME,
2264 selector,
2265 ),
2266 );
2267 };
2268 DECODE_SHIMS[idx](data)
2269 }
2270 #[inline]
2271 #[allow(non_snake_case)]
2272 fn abi_decode_raw_validate(
2273 selector: [u8; 4],
2274 data: &[u8],
2275 ) -> alloy_sol_types::Result<Self> {
2276 static DECODE_VALIDATE_SHIMS: &[fn(
2277 &[u8],
2278 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleErrors>] = &[
2279 {
2280 fn WinProbMustNotBeSame(
2281 data: &[u8],
2282 ) -> alloy_sol_types::Result<HoprWinningProbabilityOracleErrors> {
2283 <WinProbMustNotBeSame as alloy_sol_types::SolError>::abi_decode_raw_validate(
2284 data,
2285 )
2286 .map(
2287 HoprWinningProbabilityOracleErrors::WinProbMustNotBeSame,
2288 )
2289 }
2290 WinProbMustNotBeSame
2291 },
2292 ];
2293 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
2294 return Err(
2295 alloy_sol_types::Error::unknown_selector(
2296 <Self as alloy_sol_types::SolInterface>::NAME,
2297 selector,
2298 ),
2299 );
2300 };
2301 DECODE_VALIDATE_SHIMS[idx](data)
2302 }
2303 #[inline]
2304 fn abi_encoded_size(&self) -> usize {
2305 match self {
2306 Self::WinProbMustNotBeSame(inner) => {
2307 <WinProbMustNotBeSame as alloy_sol_types::SolError>::abi_encoded_size(
2308 inner,
2309 )
2310 }
2311 }
2312 }
2313 #[inline]
2314 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
2315 match self {
2316 Self::WinProbMustNotBeSame(inner) => {
2317 <WinProbMustNotBeSame as alloy_sol_types::SolError>::abi_encode_raw(
2318 inner,
2319 out,
2320 )
2321 }
2322 }
2323 }
2324 }
2325 #[derive(serde::Serialize, serde::Deserialize)]
2327 #[derive(Debug, PartialEq, Eq, Hash)]
2328 pub enum HoprWinningProbabilityOracleEvents {
2329 #[allow(missing_docs)]
2330 OwnershipTransferStarted(OwnershipTransferStarted),
2331 #[allow(missing_docs)]
2332 OwnershipTransferred(OwnershipTransferred),
2333 #[allow(missing_docs)]
2334 WinProbUpdated(WinProbUpdated),
2335 }
2336 #[automatically_derived]
2337 impl HoprWinningProbabilityOracleEvents {
2338 pub const SELECTORS: &'static [[u8; 32usize]] = &[
2345 [
2346 2u8, 114u8, 140u8, 74u8, 128u8, 55u8, 63u8, 71u8, 101u8, 85u8, 157u8,
2347 195u8, 160u8, 70u8, 237u8, 234u8, 136u8, 24u8, 100u8, 36u8, 130u8, 114u8,
2348 56u8, 187u8, 70u8, 36u8, 86u8, 104u8, 49u8, 93u8, 56u8, 0u8,
2349 ],
2350 [
2351 56u8, 209u8, 107u8, 140u8, 172u8, 34u8, 217u8, 159u8, 199u8, 193u8, 36u8,
2352 185u8, 205u8, 13u8, 226u8, 211u8, 250u8, 31u8, 174u8, 244u8, 32u8, 191u8,
2353 231u8, 145u8, 216u8, 195u8, 98u8, 215u8, 101u8, 226u8, 39u8, 0u8,
2354 ],
2355 [
2356 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
2357 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
2358 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
2359 ],
2360 ];
2361 }
2362 #[automatically_derived]
2363 impl alloy_sol_types::SolEventInterface for HoprWinningProbabilityOracleEvents {
2364 const NAME: &'static str = "HoprWinningProbabilityOracleEvents";
2365 const COUNT: usize = 3usize;
2366 fn decode_raw_log(
2367 topics: &[alloy_sol_types::Word],
2368 data: &[u8],
2369 ) -> alloy_sol_types::Result<Self> {
2370 match topics.first().copied() {
2371 Some(
2372 <OwnershipTransferStarted as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
2373 ) => {
2374 <OwnershipTransferStarted as alloy_sol_types::SolEvent>::decode_raw_log(
2375 topics,
2376 data,
2377 )
2378 .map(Self::OwnershipTransferStarted)
2379 }
2380 Some(
2381 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
2382 ) => {
2383 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
2384 topics,
2385 data,
2386 )
2387 .map(Self::OwnershipTransferred)
2388 }
2389 Some(<WinProbUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
2390 <WinProbUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
2391 topics,
2392 data,
2393 )
2394 .map(Self::WinProbUpdated)
2395 }
2396 _ => {
2397 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
2398 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
2399 log: alloy_sol_types::private::Box::new(
2400 alloy_sol_types::private::LogData::new_unchecked(
2401 topics.to_vec(),
2402 data.to_vec().into(),
2403 ),
2404 ),
2405 })
2406 }
2407 }
2408 }
2409 }
2410 #[automatically_derived]
2411 impl alloy_sol_types::private::IntoLogData for HoprWinningProbabilityOracleEvents {
2412 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2413 match self {
2414 Self::OwnershipTransferStarted(inner) => {
2415 alloy_sol_types::private::IntoLogData::to_log_data(inner)
2416 }
2417 Self::OwnershipTransferred(inner) => {
2418 alloy_sol_types::private::IntoLogData::to_log_data(inner)
2419 }
2420 Self::WinProbUpdated(inner) => {
2421 alloy_sol_types::private::IntoLogData::to_log_data(inner)
2422 }
2423 }
2424 }
2425 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2426 match self {
2427 Self::OwnershipTransferStarted(inner) => {
2428 alloy_sol_types::private::IntoLogData::into_log_data(inner)
2429 }
2430 Self::OwnershipTransferred(inner) => {
2431 alloy_sol_types::private::IntoLogData::into_log_data(inner)
2432 }
2433 Self::WinProbUpdated(inner) => {
2434 alloy_sol_types::private::IntoLogData::into_log_data(inner)
2435 }
2436 }
2437 }
2438 }
2439 use alloy::contract as alloy_contract;
2440 #[inline]
2444 pub const fn new<
2445 P: alloy_contract::private::Provider<N>,
2446 N: alloy_contract::private::Network,
2447 >(
2448 address: alloy_sol_types::private::Address,
2449 provider: P,
2450 ) -> HoprWinningProbabilityOracleInstance<P, N> {
2451 HoprWinningProbabilityOracleInstance::<P, N>::new(address, provider)
2452 }
2453 #[inline]
2459 pub fn deploy<
2460 P: alloy_contract::private::Provider<N>,
2461 N: alloy_contract::private::Network,
2462 >(
2463 provider: P,
2464 _newOwner: alloy::sol_types::private::Address,
2465 _initialWinProb: <WinProb as alloy::sol_types::SolType>::RustType,
2466 ) -> impl ::core::future::Future<
2467 Output = alloy_contract::Result<HoprWinningProbabilityOracleInstance<P, N>>,
2468 > {
2469 HoprWinningProbabilityOracleInstance::<
2470 P,
2471 N,
2472 >::deploy(provider, _newOwner, _initialWinProb)
2473 }
2474 #[inline]
2480 pub fn deploy_builder<
2481 P: alloy_contract::private::Provider<N>,
2482 N: alloy_contract::private::Network,
2483 >(
2484 provider: P,
2485 _newOwner: alloy::sol_types::private::Address,
2486 _initialWinProb: <WinProb as alloy::sol_types::SolType>::RustType,
2487 ) -> alloy_contract::RawCallBuilder<P, N> {
2488 HoprWinningProbabilityOracleInstance::<
2489 P,
2490 N,
2491 >::deploy_builder(provider, _newOwner, _initialWinProb)
2492 }
2493 #[derive(Clone)]
2505 pub struct HoprWinningProbabilityOracleInstance<
2506 P,
2507 N = alloy_contract::private::Ethereum,
2508 > {
2509 address: alloy_sol_types::private::Address,
2510 provider: P,
2511 _network: ::core::marker::PhantomData<N>,
2512 }
2513 #[automatically_derived]
2514 impl<P, N> ::core::fmt::Debug for HoprWinningProbabilityOracleInstance<P, N> {
2515 #[inline]
2516 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
2517 f.debug_tuple("HoprWinningProbabilityOracleInstance")
2518 .field(&self.address)
2519 .finish()
2520 }
2521 }
2522 #[automatically_derived]
2524 impl<
2525 P: alloy_contract::private::Provider<N>,
2526 N: alloy_contract::private::Network,
2527 > HoprWinningProbabilityOracleInstance<P, N> {
2528 #[inline]
2532 pub const fn new(
2533 address: alloy_sol_types::private::Address,
2534 provider: P,
2535 ) -> Self {
2536 Self {
2537 address,
2538 provider,
2539 _network: ::core::marker::PhantomData,
2540 }
2541 }
2542 #[inline]
2548 pub async fn deploy(
2549 provider: P,
2550 _newOwner: alloy::sol_types::private::Address,
2551 _initialWinProb: <WinProb as alloy::sol_types::SolType>::RustType,
2552 ) -> alloy_contract::Result<HoprWinningProbabilityOracleInstance<P, N>> {
2553 let call_builder = Self::deploy_builder(
2554 provider,
2555 _newOwner,
2556 _initialWinProb,
2557 );
2558 let contract_address = call_builder.deploy().await?;
2559 Ok(Self::new(contract_address, call_builder.provider))
2560 }
2561 #[inline]
2567 pub fn deploy_builder(
2568 provider: P,
2569 _newOwner: alloy::sol_types::private::Address,
2570 _initialWinProb: <WinProb as alloy::sol_types::SolType>::RustType,
2571 ) -> alloy_contract::RawCallBuilder<P, N> {
2572 alloy_contract::RawCallBuilder::new_raw_deploy(
2573 provider,
2574 [
2575 &BYTECODE[..],
2576 &alloy_sol_types::SolConstructor::abi_encode(
2577 &constructorCall {
2578 _newOwner,
2579 _initialWinProb,
2580 },
2581 )[..],
2582 ]
2583 .concat()
2584 .into(),
2585 )
2586 }
2587 #[inline]
2589 pub const fn address(&self) -> &alloy_sol_types::private::Address {
2590 &self.address
2591 }
2592 #[inline]
2594 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
2595 self.address = address;
2596 }
2597 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
2599 self.set_address(address);
2600 self
2601 }
2602 #[inline]
2604 pub const fn provider(&self) -> &P {
2605 &self.provider
2606 }
2607 }
2608 impl<P: ::core::clone::Clone, N> HoprWinningProbabilityOracleInstance<&P, N> {
2609 #[inline]
2611 pub fn with_cloned_provider(self) -> HoprWinningProbabilityOracleInstance<P, N> {
2612 HoprWinningProbabilityOracleInstance {
2613 address: self.address,
2614 provider: ::core::clone::Clone::clone(&self.provider),
2615 _network: ::core::marker::PhantomData,
2616 }
2617 }
2618 }
2619 #[automatically_derived]
2621 impl<
2622 P: alloy_contract::private::Provider<N>,
2623 N: alloy_contract::private::Network,
2624 > HoprWinningProbabilityOracleInstance<P, N> {
2625 pub fn call_builder<C: alloy_sol_types::SolCall>(
2630 &self,
2631 call: &C,
2632 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
2633 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
2634 }
2635 pub fn acceptOwnership(
2637 &self,
2638 ) -> alloy_contract::SolCallBuilder<&P, acceptOwnershipCall, N> {
2639 self.call_builder(&acceptOwnershipCall)
2640 }
2641 pub fn currentWinProb(
2643 &self,
2644 ) -> alloy_contract::SolCallBuilder<&P, currentWinProbCall, N> {
2645 self.call_builder(¤tWinProbCall)
2646 }
2647 pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
2649 self.call_builder(&ownerCall)
2650 }
2651 pub fn pendingOwner(
2653 &self,
2654 ) -> alloy_contract::SolCallBuilder<&P, pendingOwnerCall, N> {
2655 self.call_builder(&pendingOwnerCall)
2656 }
2657 pub fn renounceOwnership(
2659 &self,
2660 ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
2661 self.call_builder(&renounceOwnershipCall)
2662 }
2663 pub fn setWinProb(
2665 &self,
2666 _newWinProb: <WinProb as alloy::sol_types::SolType>::RustType,
2667 ) -> alloy_contract::SolCallBuilder<&P, setWinProbCall, N> {
2668 self.call_builder(&setWinProbCall { _newWinProb })
2669 }
2670 pub fn transferOwnership(
2672 &self,
2673 newOwner: alloy::sol_types::private::Address,
2674 ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
2675 self.call_builder(&transferOwnershipCall { newOwner })
2676 }
2677 }
2678 #[automatically_derived]
2680 impl<
2681 P: alloy_contract::private::Provider<N>,
2682 N: alloy_contract::private::Network,
2683 > HoprWinningProbabilityOracleInstance<P, N> {
2684 pub fn event_filter<E: alloy_sol_types::SolEvent>(
2689 &self,
2690 ) -> alloy_contract::Event<&P, E, N> {
2691 alloy_contract::Event::new_sol(&self.provider, &self.address)
2692 }
2693 pub fn OwnershipTransferStarted_filter(
2695 &self,
2696 ) -> alloy_contract::Event<&P, OwnershipTransferStarted, N> {
2697 self.event_filter::<OwnershipTransferStarted>()
2698 }
2699 pub fn OwnershipTransferred_filter(
2701 &self,
2702 ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
2703 self.event_filter::<OwnershipTransferred>()
2704 }
2705 pub fn WinProbUpdated_filter(
2707 &self,
2708 ) -> alloy_contract::Event<&P, WinProbUpdated, N> {
2709 self.event_filter::<WinProbUpdated>()
2710 }
2711 }
2712}