1#[allow(
151 non_camel_case_types,
152 non_snake_case,
153 clippy::pub_underscore_fields,
154 clippy::style,
155 clippy::empty_structs_with_brackets
156)]
157pub mod HoprTicketPriceOracle {
158 use super::*;
159 use alloy::sol_types as alloy_sol_types;
160 #[rustfmt::skip]
166 #[allow(clippy::all)]
167 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
168 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`@Qa\x05c8\x03\x80a\x05c\x839\x81\x01`@\x81\x90Ra\0/\x91a\x02\x03V[a\083a\0QV[a\0A\x82a\0\xA1V[a\0J\x81a\x01\x1FV[PPa\x02=V[`\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[a\0\xA9a\x01\xA7V[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x01\x13W`@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\x01\x1C\x81a\0QV[PV[\x80`\0\x03a\x01@W`@QcE\xB2W\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x81\x03a\x01bW`@Qc\x9B$\xE99`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01\x80T\x90\x82\x90U`@\x80Q\x82\x81R` \x81\x01\x84\x90R\x7F\xD4\xC5\xE0k\x1A\xE0\x97\xBA\x027&R\xA7\xAD\xAAnJ\x8E\0\xBERt\x97\xA3\xAD\x0E\xBC?v\x1E\xF3\xFB\x91\x01`@Q\x80\x91\x03\x90\xA1PPV[`\0T`\x01`\x01`\xA0\x1B\x03\x163\x14a\x02\x01W`@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\nV[V[`\0\x80`@\x83\x85\x03\x12\x15a\x02\x16W`\0\x80\xFD[\x82Q`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02-W`\0\x80\xFD[` \x93\x90\x93\x01Q\x92\x94\x92\x93PPPV[a\x03\x17\x80a\x02L`\09`\0\xF3\xFE`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0WW`\x005`\xE0\x1C\x80c\x15\x98\x16P\x14a\0\\W\x80cqP\x18\xA6\x14a\0qW\x80c\x8D\xA5\xCB[\x14a\0yW\x80c\xE0\x15\x91\x06\x14a\0\x99W\x80c\xF2\xFD\xE3\x8B\x14a\0\xB0W[`\0\x80\xFD[a\0oa\0j6`\x04a\x02\x98V[a\0\xC3V[\0[a\0oa\0\xD7V[`\0T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xA2`\x01T\x81V[`@Q\x90\x81R` \x01a\0\x90V[a\0oa\0\xBE6`\x04a\x02\xB1V[a\0\xEBV[a\0\xCBa\x01fV[a\0\xD4\x81a\x01\xC0V[PV[a\0\xDFa\x01fV[a\0\xE9`\0a\x02HV[V[a\0\xF3a\x01fV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x01]W`@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\0\xD4\x81a\x02HV[`\0T`\x01`\x01`\xA0\x1B\x03\x163\x14a\0\xE9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x01TV[\x80`\0\x03a\x01\xE1W`@QcE\xB2W\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x81\x03a\x02\x03W`@Qc\x9B$\xE99`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01\x80T\x90\x82\x90U`@\x80Q\x82\x81R` \x81\x01\x84\x90R\x7F\xD4\xC5\xE0k\x1A\xE0\x97\xBA\x027&R\xA7\xAD\xAAnJ\x8E\0\xBERt\x97\xA3\xAD\x0E\xBC?v\x1E\xF3\xFB\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\x02\xAAW`\0\x80\xFD[P5\x91\x90PV[`\0` \x82\x84\x03\x12\x15a\x02\xC3W`\0\x80\xFD[\x815`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02\xDAW`\0\x80\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x80\xF8'\xDE\x88>\xA1\xD8\x0B\xBC^\x1C\xC1\xD9F\xF4\xCB\xCE\xF3\x86{j\xC3\x16\x12\xEE\x17[\xF2$\xD5bdsolcC\0\x08\x13\x003",
169 );
170 #[rustfmt::skip]
176 #[allow(clippy::all)]
177 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
178 b"`\x80`@R4\x80\x15a\0\x10W`\0\x80\xFD[P`\x046\x10a\0WW`\x005`\xE0\x1C\x80c\x15\x98\x16P\x14a\0\\W\x80cqP\x18\xA6\x14a\0qW\x80c\x8D\xA5\xCB[\x14a\0yW\x80c\xE0\x15\x91\x06\x14a\0\x99W\x80c\xF2\xFD\xE3\x8B\x14a\0\xB0W[`\0\x80\xFD[a\0oa\0j6`\x04a\x02\x98V[a\0\xC3V[\0[a\0oa\0\xD7V[`\0T`@Q`\x01`\x01`\xA0\x1B\x03\x90\x91\x16\x81R` \x01[`@Q\x80\x91\x03\x90\xF3[a\0\xA2`\x01T\x81V[`@Q\x90\x81R` \x01a\0\x90V[a\0oa\0\xBE6`\x04a\x02\xB1V[a\0\xEBV[a\0\xCBa\x01fV[a\0\xD4\x81a\x01\xC0V[PV[a\0\xDFa\x01fV[a\0\xE9`\0a\x02HV[V[a\0\xF3a\x01fV[`\x01`\x01`\xA0\x1B\x03\x81\x16a\x01]W`@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\0\xD4\x81a\x02HV[`\0T`\x01`\x01`\xA0\x1B\x03\x163\x14a\0\xE9W`@QbF\x1B\xCD`\xE5\x1B\x81R` `\x04\x82\x01\x81\x90R`$\x82\x01R\x7FOwnable: caller is not the owner`D\x82\x01R`d\x01a\x01TV[\x80`\0\x03a\x01\xE1W`@QcE\xB2W\xEF`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01T\x81\x03a\x02\x03W`@Qc\x9B$\xE99`\xE0\x1B\x81R`\x04\x01`@Q\x80\x91\x03\x90\xFD[`\x01\x80T\x90\x82\x90U`@\x80Q\x82\x81R` \x81\x01\x84\x90R\x7F\xD4\xC5\xE0k\x1A\xE0\x97\xBA\x027&R\xA7\xAD\xAAnJ\x8E\0\xBERt\x97\xA3\xAD\x0E\xBC?v\x1E\xF3\xFB\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\x02\xAAW`\0\x80\xFD[P5\x91\x90PV[`\0` \x82\x84\x03\x12\x15a\x02\xC3W`\0\x80\xFD[\x815`\x01`\x01`\xA0\x1B\x03\x81\x16\x81\x14a\x02\xDAW`\0\x80\xFD[\x93\x92PPPV\xFE\xA2dipfsX\"\x12 \x80\xF8'\xDE\x88>\xA1\xD8\x0B\xBC^\x1C\xC1\xD9F\xF4\xCB\xCE\xF3\x86{j\xC3\x16\x12\xEE\x17[\xF2$\xD5bdsolcC\0\x08\x13\x003",
179 );
180 #[derive(serde::Serialize, serde::Deserialize)]
181 #[derive(Default, Debug, PartialEq, Eq, Hash)]
182 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
187 #[derive(Clone)]
188 pub struct TicketPriceMustNotBeSame;
189 #[allow(
190 non_camel_case_types,
191 non_snake_case,
192 clippy::pub_underscore_fields,
193 clippy::style
194 )]
195 const _: () = {
196 use alloy::sol_types as alloy_sol_types;
197 #[doc(hidden)]
198 type UnderlyingSolTuple<'a> = ();
199 #[doc(hidden)]
200 type UnderlyingRustTuple<'a> = ();
201 #[cfg(test)]
202 #[allow(dead_code, unreachable_patterns)]
203 fn _type_assertion(
204 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
205 ) {
206 match _t {
207 alloy_sol_types::private::AssertTypeEq::<
208 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
209 >(_) => {}
210 }
211 }
212 #[automatically_derived]
213 #[doc(hidden)]
214 impl ::core::convert::From<TicketPriceMustNotBeSame>
215 for UnderlyingRustTuple<'_> {
216 fn from(value: TicketPriceMustNotBeSame) -> Self {
217 ()
218 }
219 }
220 #[automatically_derived]
221 #[doc(hidden)]
222 impl ::core::convert::From<UnderlyingRustTuple<'_>>
223 for TicketPriceMustNotBeSame {
224 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
225 Self
226 }
227 }
228 #[automatically_derived]
229 impl alloy_sol_types::SolError for TicketPriceMustNotBeSame {
230 type Parameters<'a> = UnderlyingSolTuple<'a>;
231 type Token<'a> = <Self::Parameters<
232 'a,
233 > as alloy_sol_types::SolType>::Token<'a>;
234 const SIGNATURE: &'static str = "TicketPriceMustNotBeSame()";
235 const SELECTOR: [u8; 4] = [155u8, 36u8, 233u8, 57u8];
236 #[inline]
237 fn new<'a>(
238 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
239 ) -> Self {
240 tuple.into()
241 }
242 #[inline]
243 fn tokenize(&self) -> Self::Token<'_> {
244 ()
245 }
246 #[inline]
247 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
248 <Self::Parameters<
249 '_,
250 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
251 .map(Self::new)
252 }
253 }
254 };
255 #[derive(serde::Serialize, serde::Deserialize)]
256 #[derive(Default, Debug, PartialEq, Eq, Hash)]
257 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
262 #[derive(Clone)]
263 pub struct TicketPriceMustNotBeZero;
264 #[allow(
265 non_camel_case_types,
266 non_snake_case,
267 clippy::pub_underscore_fields,
268 clippy::style
269 )]
270 const _: () = {
271 use alloy::sol_types as alloy_sol_types;
272 #[doc(hidden)]
273 type UnderlyingSolTuple<'a> = ();
274 #[doc(hidden)]
275 type UnderlyingRustTuple<'a> = ();
276 #[cfg(test)]
277 #[allow(dead_code, unreachable_patterns)]
278 fn _type_assertion(
279 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
280 ) {
281 match _t {
282 alloy_sol_types::private::AssertTypeEq::<
283 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
284 >(_) => {}
285 }
286 }
287 #[automatically_derived]
288 #[doc(hidden)]
289 impl ::core::convert::From<TicketPriceMustNotBeZero>
290 for UnderlyingRustTuple<'_> {
291 fn from(value: TicketPriceMustNotBeZero) -> Self {
292 ()
293 }
294 }
295 #[automatically_derived]
296 #[doc(hidden)]
297 impl ::core::convert::From<UnderlyingRustTuple<'_>>
298 for TicketPriceMustNotBeZero {
299 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
300 Self
301 }
302 }
303 #[automatically_derived]
304 impl alloy_sol_types::SolError for TicketPriceMustNotBeZero {
305 type Parameters<'a> = UnderlyingSolTuple<'a>;
306 type Token<'a> = <Self::Parameters<
307 'a,
308 > as alloy_sol_types::SolType>::Token<'a>;
309 const SIGNATURE: &'static str = "TicketPriceMustNotBeZero()";
310 const SELECTOR: [u8; 4] = [69u8, 178u8, 87u8, 239u8];
311 #[inline]
312 fn new<'a>(
313 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
314 ) -> Self {
315 tuple.into()
316 }
317 #[inline]
318 fn tokenize(&self) -> Self::Token<'_> {
319 ()
320 }
321 #[inline]
322 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
323 <Self::Parameters<
324 '_,
325 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
326 .map(Self::new)
327 }
328 }
329 };
330 #[derive(serde::Serialize, serde::Deserialize)]
331 #[derive(Default, Debug, PartialEq, Eq, Hash)]
332 #[allow(
337 non_camel_case_types,
338 non_snake_case,
339 clippy::pub_underscore_fields,
340 clippy::style
341 )]
342 #[derive(Clone)]
343 pub struct OwnershipTransferred {
344 #[allow(missing_docs)]
345 pub previousOwner: alloy::sol_types::private::Address,
346 #[allow(missing_docs)]
347 pub newOwner: alloy::sol_types::private::Address,
348 }
349 #[allow(
350 non_camel_case_types,
351 non_snake_case,
352 clippy::pub_underscore_fields,
353 clippy::style
354 )]
355 const _: () = {
356 use alloy::sol_types as alloy_sol_types;
357 #[automatically_derived]
358 impl alloy_sol_types::SolEvent for OwnershipTransferred {
359 type DataTuple<'a> = ();
360 type DataToken<'a> = <Self::DataTuple<
361 'a,
362 > as alloy_sol_types::SolType>::Token<'a>;
363 type TopicList = (
364 alloy_sol_types::sol_data::FixedBytes<32>,
365 alloy::sol_types::sol_data::Address,
366 alloy::sol_types::sol_data::Address,
367 );
368 const SIGNATURE: &'static str = "OwnershipTransferred(address,address)";
369 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
370 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
371 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
372 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
373 ]);
374 const ANONYMOUS: bool = false;
375 #[allow(unused_variables)]
376 #[inline]
377 fn new(
378 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
379 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
380 ) -> Self {
381 Self {
382 previousOwner: topics.1,
383 newOwner: topics.2,
384 }
385 }
386 #[inline]
387 fn check_signature(
388 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
389 ) -> alloy_sol_types::Result<()> {
390 if topics.0 != Self::SIGNATURE_HASH {
391 return Err(
392 alloy_sol_types::Error::invalid_event_signature_hash(
393 Self::SIGNATURE,
394 topics.0,
395 Self::SIGNATURE_HASH,
396 ),
397 );
398 }
399 Ok(())
400 }
401 #[inline]
402 fn tokenize_body(&self) -> Self::DataToken<'_> {
403 ()
404 }
405 #[inline]
406 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
407 (
408 Self::SIGNATURE_HASH.into(),
409 self.previousOwner.clone(),
410 self.newOwner.clone(),
411 )
412 }
413 #[inline]
414 fn encode_topics_raw(
415 &self,
416 out: &mut [alloy_sol_types::abi::token::WordToken],
417 ) -> alloy_sol_types::Result<()> {
418 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
419 return Err(alloy_sol_types::Error::Overrun);
420 }
421 out[0usize] = alloy_sol_types::abi::token::WordToken(
422 Self::SIGNATURE_HASH,
423 );
424 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
425 &self.previousOwner,
426 );
427 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
428 &self.newOwner,
429 );
430 Ok(())
431 }
432 }
433 #[automatically_derived]
434 impl alloy_sol_types::private::IntoLogData for OwnershipTransferred {
435 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
436 From::from(self)
437 }
438 fn into_log_data(self) -> alloy_sol_types::private::LogData {
439 From::from(&self)
440 }
441 }
442 #[automatically_derived]
443 impl From<&OwnershipTransferred> for alloy_sol_types::private::LogData {
444 #[inline]
445 fn from(this: &OwnershipTransferred) -> alloy_sol_types::private::LogData {
446 alloy_sol_types::SolEvent::encode_log_data(this)
447 }
448 }
449 };
450 #[derive(serde::Serialize, serde::Deserialize)]
451 #[derive(Default, Debug, PartialEq, Eq, Hash)]
452 #[allow(
457 non_camel_case_types,
458 non_snake_case,
459 clippy::pub_underscore_fields,
460 clippy::style
461 )]
462 #[derive(Clone)]
463 pub struct TicketPriceUpdated {
464 #[allow(missing_docs)]
465 pub _0: alloy::sol_types::private::primitives::aliases::U256,
466 #[allow(missing_docs)]
467 pub _1: alloy::sol_types::private::primitives::aliases::U256,
468 }
469 #[allow(
470 non_camel_case_types,
471 non_snake_case,
472 clippy::pub_underscore_fields,
473 clippy::style
474 )]
475 const _: () = {
476 use alloy::sol_types as alloy_sol_types;
477 #[automatically_derived]
478 impl alloy_sol_types::SolEvent for TicketPriceUpdated {
479 type DataTuple<'a> = (
480 alloy::sol_types::sol_data::Uint<256>,
481 alloy::sol_types::sol_data::Uint<256>,
482 );
483 type DataToken<'a> = <Self::DataTuple<
484 'a,
485 > as alloy_sol_types::SolType>::Token<'a>;
486 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
487 const SIGNATURE: &'static str = "TicketPriceUpdated(uint256,uint256)";
488 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
489 212u8, 197u8, 224u8, 107u8, 26u8, 224u8, 151u8, 186u8, 2u8, 55u8, 38u8,
490 82u8, 167u8, 173u8, 170u8, 110u8, 74u8, 142u8, 0u8, 190u8, 82u8, 116u8,
491 151u8, 163u8, 173u8, 14u8, 188u8, 63u8, 118u8, 30u8, 243u8, 251u8,
492 ]);
493 const ANONYMOUS: bool = false;
494 #[allow(unused_variables)]
495 #[inline]
496 fn new(
497 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
498 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
499 ) -> Self {
500 Self { _0: data.0, _1: data.1 }
501 }
502 #[inline]
503 fn check_signature(
504 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
505 ) -> alloy_sol_types::Result<()> {
506 if topics.0 != Self::SIGNATURE_HASH {
507 return Err(
508 alloy_sol_types::Error::invalid_event_signature_hash(
509 Self::SIGNATURE,
510 topics.0,
511 Self::SIGNATURE_HASH,
512 ),
513 );
514 }
515 Ok(())
516 }
517 #[inline]
518 fn tokenize_body(&self) -> Self::DataToken<'_> {
519 (
520 <alloy::sol_types::sol_data::Uint<
521 256,
522 > as alloy_sol_types::SolType>::tokenize(&self._0),
523 <alloy::sol_types::sol_data::Uint<
524 256,
525 > as alloy_sol_types::SolType>::tokenize(&self._1),
526 )
527 }
528 #[inline]
529 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
530 (Self::SIGNATURE_HASH.into(),)
531 }
532 #[inline]
533 fn encode_topics_raw(
534 &self,
535 out: &mut [alloy_sol_types::abi::token::WordToken],
536 ) -> alloy_sol_types::Result<()> {
537 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
538 return Err(alloy_sol_types::Error::Overrun);
539 }
540 out[0usize] = alloy_sol_types::abi::token::WordToken(
541 Self::SIGNATURE_HASH,
542 );
543 Ok(())
544 }
545 }
546 #[automatically_derived]
547 impl alloy_sol_types::private::IntoLogData for TicketPriceUpdated {
548 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
549 From::from(self)
550 }
551 fn into_log_data(self) -> alloy_sol_types::private::LogData {
552 From::from(&self)
553 }
554 }
555 #[automatically_derived]
556 impl From<&TicketPriceUpdated> for alloy_sol_types::private::LogData {
557 #[inline]
558 fn from(this: &TicketPriceUpdated) -> alloy_sol_types::private::LogData {
559 alloy_sol_types::SolEvent::encode_log_data(this)
560 }
561 }
562 };
563 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
568 #[derive(Clone)]
569 pub struct constructorCall {
570 #[allow(missing_docs)]
571 pub _newOwner: alloy::sol_types::private::Address,
572 #[allow(missing_docs)]
573 pub _initialTicketPrice: alloy::sol_types::private::primitives::aliases::U256,
574 }
575 const _: () = {
576 use alloy::sol_types as alloy_sol_types;
577 {
578 #[doc(hidden)]
579 type UnderlyingSolTuple<'a> = (
580 alloy::sol_types::sol_data::Address,
581 alloy::sol_types::sol_data::Uint<256>,
582 );
583 #[doc(hidden)]
584 type UnderlyingRustTuple<'a> = (
585 alloy::sol_types::private::Address,
586 alloy::sol_types::private::primitives::aliases::U256,
587 );
588 #[cfg(test)]
589 #[allow(dead_code, unreachable_patterns)]
590 fn _type_assertion(
591 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
592 ) {
593 match _t {
594 alloy_sol_types::private::AssertTypeEq::<
595 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
596 >(_) => {}
597 }
598 }
599 #[automatically_derived]
600 #[doc(hidden)]
601 impl ::core::convert::From<constructorCall> for UnderlyingRustTuple<'_> {
602 fn from(value: constructorCall) -> Self {
603 (value._newOwner, value._initialTicketPrice)
604 }
605 }
606 #[automatically_derived]
607 #[doc(hidden)]
608 impl ::core::convert::From<UnderlyingRustTuple<'_>> for constructorCall {
609 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
610 Self {
611 _newOwner: tuple.0,
612 _initialTicketPrice: tuple.1,
613 }
614 }
615 }
616 }
617 #[automatically_derived]
618 impl alloy_sol_types::SolConstructor for constructorCall {
619 type Parameters<'a> = (
620 alloy::sol_types::sol_data::Address,
621 alloy::sol_types::sol_data::Uint<256>,
622 );
623 type Token<'a> = <Self::Parameters<
624 'a,
625 > as alloy_sol_types::SolType>::Token<'a>;
626 #[inline]
627 fn new<'a>(
628 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
629 ) -> Self {
630 tuple.into()
631 }
632 #[inline]
633 fn tokenize(&self) -> Self::Token<'_> {
634 (
635 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
636 &self._newOwner,
637 ),
638 <alloy::sol_types::sol_data::Uint<
639 256,
640 > as alloy_sol_types::SolType>::tokenize(&self._initialTicketPrice),
641 )
642 }
643 }
644 };
645 #[derive(serde::Serialize, serde::Deserialize)]
646 #[derive(Default, Debug, PartialEq, Eq, Hash)]
647 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
652 #[derive(Clone)]
653 pub struct currentTicketPriceCall;
654 #[derive(serde::Serialize, serde::Deserialize)]
655 #[derive(Default, Debug, PartialEq, Eq, Hash)]
656 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
658 #[derive(Clone)]
659 pub struct currentTicketPriceReturn {
660 #[allow(missing_docs)]
661 pub _0: alloy::sol_types::private::primitives::aliases::U256,
662 }
663 #[allow(
664 non_camel_case_types,
665 non_snake_case,
666 clippy::pub_underscore_fields,
667 clippy::style
668 )]
669 const _: () = {
670 use alloy::sol_types as alloy_sol_types;
671 {
672 #[doc(hidden)]
673 type UnderlyingSolTuple<'a> = ();
674 #[doc(hidden)]
675 type UnderlyingRustTuple<'a> = ();
676 #[cfg(test)]
677 #[allow(dead_code, unreachable_patterns)]
678 fn _type_assertion(
679 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
680 ) {
681 match _t {
682 alloy_sol_types::private::AssertTypeEq::<
683 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
684 >(_) => {}
685 }
686 }
687 #[automatically_derived]
688 #[doc(hidden)]
689 impl ::core::convert::From<currentTicketPriceCall>
690 for UnderlyingRustTuple<'_> {
691 fn from(value: currentTicketPriceCall) -> Self {
692 ()
693 }
694 }
695 #[automatically_derived]
696 #[doc(hidden)]
697 impl ::core::convert::From<UnderlyingRustTuple<'_>>
698 for currentTicketPriceCall {
699 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
700 Self
701 }
702 }
703 }
704 {
705 #[doc(hidden)]
706 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
707 #[doc(hidden)]
708 type UnderlyingRustTuple<'a> = (
709 alloy::sol_types::private::primitives::aliases::U256,
710 );
711 #[cfg(test)]
712 #[allow(dead_code, unreachable_patterns)]
713 fn _type_assertion(
714 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
715 ) {
716 match _t {
717 alloy_sol_types::private::AssertTypeEq::<
718 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
719 >(_) => {}
720 }
721 }
722 #[automatically_derived]
723 #[doc(hidden)]
724 impl ::core::convert::From<currentTicketPriceReturn>
725 for UnderlyingRustTuple<'_> {
726 fn from(value: currentTicketPriceReturn) -> Self {
727 (value._0,)
728 }
729 }
730 #[automatically_derived]
731 #[doc(hidden)]
732 impl ::core::convert::From<UnderlyingRustTuple<'_>>
733 for currentTicketPriceReturn {
734 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
735 Self { _0: tuple.0 }
736 }
737 }
738 }
739 #[automatically_derived]
740 impl alloy_sol_types::SolCall for currentTicketPriceCall {
741 type Parameters<'a> = ();
742 type Token<'a> = <Self::Parameters<
743 'a,
744 > as alloy_sol_types::SolType>::Token<'a>;
745 type Return = alloy::sol_types::private::primitives::aliases::U256;
746 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
747 type ReturnToken<'a> = <Self::ReturnTuple<
748 'a,
749 > as alloy_sol_types::SolType>::Token<'a>;
750 const SIGNATURE: &'static str = "currentTicketPrice()";
751 const SELECTOR: [u8; 4] = [224u8, 21u8, 145u8, 6u8];
752 #[inline]
753 fn new<'a>(
754 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
755 ) -> Self {
756 tuple.into()
757 }
758 #[inline]
759 fn tokenize(&self) -> Self::Token<'_> {
760 ()
761 }
762 #[inline]
763 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
764 (
765 <alloy::sol_types::sol_data::Uint<
766 256,
767 > as alloy_sol_types::SolType>::tokenize(ret),
768 )
769 }
770 #[inline]
771 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
772 <Self::ReturnTuple<
773 '_,
774 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
775 .map(|r| {
776 let r: currentTicketPriceReturn = r.into();
777 r._0
778 })
779 }
780 #[inline]
781 fn abi_decode_returns_validate(
782 data: &[u8],
783 ) -> alloy_sol_types::Result<Self::Return> {
784 <Self::ReturnTuple<
785 '_,
786 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
787 .map(|r| {
788 let r: currentTicketPriceReturn = r.into();
789 r._0
790 })
791 }
792 }
793 };
794 #[derive(serde::Serialize, serde::Deserialize)]
795 #[derive(Default, Debug, PartialEq, Eq, Hash)]
796 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
801 #[derive(Clone)]
802 pub struct ownerCall;
803 #[derive(serde::Serialize, serde::Deserialize)]
804 #[derive(Default, Debug, PartialEq, Eq, Hash)]
805 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
807 #[derive(Clone)]
808 pub struct ownerReturn {
809 #[allow(missing_docs)]
810 pub _0: alloy::sol_types::private::Address,
811 }
812 #[allow(
813 non_camel_case_types,
814 non_snake_case,
815 clippy::pub_underscore_fields,
816 clippy::style
817 )]
818 const _: () = {
819 use alloy::sol_types as alloy_sol_types;
820 {
821 #[doc(hidden)]
822 type UnderlyingSolTuple<'a> = ();
823 #[doc(hidden)]
824 type UnderlyingRustTuple<'a> = ();
825 #[cfg(test)]
826 #[allow(dead_code, unreachable_patterns)]
827 fn _type_assertion(
828 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
829 ) {
830 match _t {
831 alloy_sol_types::private::AssertTypeEq::<
832 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
833 >(_) => {}
834 }
835 }
836 #[automatically_derived]
837 #[doc(hidden)]
838 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
839 fn from(value: ownerCall) -> Self {
840 ()
841 }
842 }
843 #[automatically_derived]
844 #[doc(hidden)]
845 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
846 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
847 Self
848 }
849 }
850 }
851 {
852 #[doc(hidden)]
853 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
854 #[doc(hidden)]
855 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
856 #[cfg(test)]
857 #[allow(dead_code, unreachable_patterns)]
858 fn _type_assertion(
859 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
860 ) {
861 match _t {
862 alloy_sol_types::private::AssertTypeEq::<
863 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
864 >(_) => {}
865 }
866 }
867 #[automatically_derived]
868 #[doc(hidden)]
869 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
870 fn from(value: ownerReturn) -> Self {
871 (value._0,)
872 }
873 }
874 #[automatically_derived]
875 #[doc(hidden)]
876 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
877 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
878 Self { _0: tuple.0 }
879 }
880 }
881 }
882 #[automatically_derived]
883 impl alloy_sol_types::SolCall for ownerCall {
884 type Parameters<'a> = ();
885 type Token<'a> = <Self::Parameters<
886 'a,
887 > as alloy_sol_types::SolType>::Token<'a>;
888 type Return = alloy::sol_types::private::Address;
889 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
890 type ReturnToken<'a> = <Self::ReturnTuple<
891 'a,
892 > as alloy_sol_types::SolType>::Token<'a>;
893 const SIGNATURE: &'static str = "owner()";
894 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
895 #[inline]
896 fn new<'a>(
897 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
898 ) -> Self {
899 tuple.into()
900 }
901 #[inline]
902 fn tokenize(&self) -> Self::Token<'_> {
903 ()
904 }
905 #[inline]
906 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
907 (
908 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
909 ret,
910 ),
911 )
912 }
913 #[inline]
914 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
915 <Self::ReturnTuple<
916 '_,
917 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
918 .map(|r| {
919 let r: ownerReturn = r.into();
920 r._0
921 })
922 }
923 #[inline]
924 fn abi_decode_returns_validate(
925 data: &[u8],
926 ) -> alloy_sol_types::Result<Self::Return> {
927 <Self::ReturnTuple<
928 '_,
929 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
930 .map(|r| {
931 let r: ownerReturn = r.into();
932 r._0
933 })
934 }
935 }
936 };
937 #[derive(serde::Serialize, serde::Deserialize)]
938 #[derive(Default, Debug, PartialEq, Eq, Hash)]
939 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
944 #[derive(Clone)]
945 pub struct renounceOwnershipCall;
946 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
948 #[derive(Clone)]
949 pub struct renounceOwnershipReturn {}
950 #[allow(
951 non_camel_case_types,
952 non_snake_case,
953 clippy::pub_underscore_fields,
954 clippy::style
955 )]
956 const _: () = {
957 use alloy::sol_types as alloy_sol_types;
958 {
959 #[doc(hidden)]
960 type UnderlyingSolTuple<'a> = ();
961 #[doc(hidden)]
962 type UnderlyingRustTuple<'a> = ();
963 #[cfg(test)]
964 #[allow(dead_code, unreachable_patterns)]
965 fn _type_assertion(
966 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
967 ) {
968 match _t {
969 alloy_sol_types::private::AssertTypeEq::<
970 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
971 >(_) => {}
972 }
973 }
974 #[automatically_derived]
975 #[doc(hidden)]
976 impl ::core::convert::From<renounceOwnershipCall>
977 for UnderlyingRustTuple<'_> {
978 fn from(value: renounceOwnershipCall) -> Self {
979 ()
980 }
981 }
982 #[automatically_derived]
983 #[doc(hidden)]
984 impl ::core::convert::From<UnderlyingRustTuple<'_>>
985 for renounceOwnershipCall {
986 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
987 Self
988 }
989 }
990 }
991 {
992 #[doc(hidden)]
993 type UnderlyingSolTuple<'a> = ();
994 #[doc(hidden)]
995 type UnderlyingRustTuple<'a> = ();
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<renounceOwnershipReturn>
1010 for UnderlyingRustTuple<'_> {
1011 fn from(value: renounceOwnershipReturn) -> Self {
1012 ()
1013 }
1014 }
1015 #[automatically_derived]
1016 #[doc(hidden)]
1017 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1018 for renounceOwnershipReturn {
1019 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1020 Self {}
1021 }
1022 }
1023 }
1024 impl renounceOwnershipReturn {
1025 fn _tokenize(
1026 &self,
1027 ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1028 ()
1029 }
1030 }
1031 #[automatically_derived]
1032 impl alloy_sol_types::SolCall for renounceOwnershipCall {
1033 type Parameters<'a> = ();
1034 type Token<'a> = <Self::Parameters<
1035 'a,
1036 > as alloy_sol_types::SolType>::Token<'a>;
1037 type Return = renounceOwnershipReturn;
1038 type ReturnTuple<'a> = ();
1039 type ReturnToken<'a> = <Self::ReturnTuple<
1040 'a,
1041 > as alloy_sol_types::SolType>::Token<'a>;
1042 const SIGNATURE: &'static str = "renounceOwnership()";
1043 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
1044 #[inline]
1045 fn new<'a>(
1046 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1047 ) -> Self {
1048 tuple.into()
1049 }
1050 #[inline]
1051 fn tokenize(&self) -> Self::Token<'_> {
1052 ()
1053 }
1054 #[inline]
1055 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1056 renounceOwnershipReturn::_tokenize(ret)
1057 }
1058 #[inline]
1059 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1060 <Self::ReturnTuple<
1061 '_,
1062 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1063 .map(Into::into)
1064 }
1065 #[inline]
1066 fn abi_decode_returns_validate(
1067 data: &[u8],
1068 ) -> alloy_sol_types::Result<Self::Return> {
1069 <Self::ReturnTuple<
1070 '_,
1071 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1072 .map(Into::into)
1073 }
1074 }
1075 };
1076 #[derive(serde::Serialize, serde::Deserialize)]
1077 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1078 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1083 #[derive(Clone)]
1084 pub struct setTicketPriceCall {
1085 #[allow(missing_docs)]
1086 pub _newTicketPrice: alloy::sol_types::private::primitives::aliases::U256,
1087 }
1088 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1090 #[derive(Clone)]
1091 pub struct setTicketPriceReturn {}
1092 #[allow(
1093 non_camel_case_types,
1094 non_snake_case,
1095 clippy::pub_underscore_fields,
1096 clippy::style
1097 )]
1098 const _: () = {
1099 use alloy::sol_types as alloy_sol_types;
1100 {
1101 #[doc(hidden)]
1102 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1103 #[doc(hidden)]
1104 type UnderlyingRustTuple<'a> = (
1105 alloy::sol_types::private::primitives::aliases::U256,
1106 );
1107 #[cfg(test)]
1108 #[allow(dead_code, unreachable_patterns)]
1109 fn _type_assertion(
1110 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1111 ) {
1112 match _t {
1113 alloy_sol_types::private::AssertTypeEq::<
1114 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1115 >(_) => {}
1116 }
1117 }
1118 #[automatically_derived]
1119 #[doc(hidden)]
1120 impl ::core::convert::From<setTicketPriceCall> for UnderlyingRustTuple<'_> {
1121 fn from(value: setTicketPriceCall) -> Self {
1122 (value._newTicketPrice,)
1123 }
1124 }
1125 #[automatically_derived]
1126 #[doc(hidden)]
1127 impl ::core::convert::From<UnderlyingRustTuple<'_>> for setTicketPriceCall {
1128 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1129 Self { _newTicketPrice: tuple.0 }
1130 }
1131 }
1132 }
1133 {
1134 #[doc(hidden)]
1135 type UnderlyingSolTuple<'a> = ();
1136 #[doc(hidden)]
1137 type UnderlyingRustTuple<'a> = ();
1138 #[cfg(test)]
1139 #[allow(dead_code, unreachable_patterns)]
1140 fn _type_assertion(
1141 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1142 ) {
1143 match _t {
1144 alloy_sol_types::private::AssertTypeEq::<
1145 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1146 >(_) => {}
1147 }
1148 }
1149 #[automatically_derived]
1150 #[doc(hidden)]
1151 impl ::core::convert::From<setTicketPriceReturn>
1152 for UnderlyingRustTuple<'_> {
1153 fn from(value: setTicketPriceReturn) -> Self {
1154 ()
1155 }
1156 }
1157 #[automatically_derived]
1158 #[doc(hidden)]
1159 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1160 for setTicketPriceReturn {
1161 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1162 Self {}
1163 }
1164 }
1165 }
1166 impl setTicketPriceReturn {
1167 fn _tokenize(
1168 &self,
1169 ) -> <setTicketPriceCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1170 ()
1171 }
1172 }
1173 #[automatically_derived]
1174 impl alloy_sol_types::SolCall for setTicketPriceCall {
1175 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1176 type Token<'a> = <Self::Parameters<
1177 'a,
1178 > as alloy_sol_types::SolType>::Token<'a>;
1179 type Return = setTicketPriceReturn;
1180 type ReturnTuple<'a> = ();
1181 type ReturnToken<'a> = <Self::ReturnTuple<
1182 'a,
1183 > as alloy_sol_types::SolType>::Token<'a>;
1184 const SIGNATURE: &'static str = "setTicketPrice(uint256)";
1185 const SELECTOR: [u8; 4] = [21u8, 152u8, 22u8, 80u8];
1186 #[inline]
1187 fn new<'a>(
1188 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1189 ) -> Self {
1190 tuple.into()
1191 }
1192 #[inline]
1193 fn tokenize(&self) -> Self::Token<'_> {
1194 (
1195 <alloy::sol_types::sol_data::Uint<
1196 256,
1197 > as alloy_sol_types::SolType>::tokenize(&self._newTicketPrice),
1198 )
1199 }
1200 #[inline]
1201 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1202 setTicketPriceReturn::_tokenize(ret)
1203 }
1204 #[inline]
1205 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1206 <Self::ReturnTuple<
1207 '_,
1208 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1209 .map(Into::into)
1210 }
1211 #[inline]
1212 fn abi_decode_returns_validate(
1213 data: &[u8],
1214 ) -> alloy_sol_types::Result<Self::Return> {
1215 <Self::ReturnTuple<
1216 '_,
1217 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1218 .map(Into::into)
1219 }
1220 }
1221 };
1222 #[derive(serde::Serialize, serde::Deserialize)]
1223 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1224 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1229 #[derive(Clone)]
1230 pub struct transferOwnershipCall {
1231 #[allow(missing_docs)]
1232 pub newOwner: alloy::sol_types::private::Address,
1233 }
1234 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1236 #[derive(Clone)]
1237 pub struct transferOwnershipReturn {}
1238 #[allow(
1239 non_camel_case_types,
1240 non_snake_case,
1241 clippy::pub_underscore_fields,
1242 clippy::style
1243 )]
1244 const _: () = {
1245 use alloy::sol_types as alloy_sol_types;
1246 {
1247 #[doc(hidden)]
1248 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1249 #[doc(hidden)]
1250 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1251 #[cfg(test)]
1252 #[allow(dead_code, unreachable_patterns)]
1253 fn _type_assertion(
1254 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1255 ) {
1256 match _t {
1257 alloy_sol_types::private::AssertTypeEq::<
1258 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1259 >(_) => {}
1260 }
1261 }
1262 #[automatically_derived]
1263 #[doc(hidden)]
1264 impl ::core::convert::From<transferOwnershipCall>
1265 for UnderlyingRustTuple<'_> {
1266 fn from(value: transferOwnershipCall) -> Self {
1267 (value.newOwner,)
1268 }
1269 }
1270 #[automatically_derived]
1271 #[doc(hidden)]
1272 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1273 for transferOwnershipCall {
1274 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1275 Self { newOwner: tuple.0 }
1276 }
1277 }
1278 }
1279 {
1280 #[doc(hidden)]
1281 type UnderlyingSolTuple<'a> = ();
1282 #[doc(hidden)]
1283 type UnderlyingRustTuple<'a> = ();
1284 #[cfg(test)]
1285 #[allow(dead_code, unreachable_patterns)]
1286 fn _type_assertion(
1287 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1288 ) {
1289 match _t {
1290 alloy_sol_types::private::AssertTypeEq::<
1291 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1292 >(_) => {}
1293 }
1294 }
1295 #[automatically_derived]
1296 #[doc(hidden)]
1297 impl ::core::convert::From<transferOwnershipReturn>
1298 for UnderlyingRustTuple<'_> {
1299 fn from(value: transferOwnershipReturn) -> Self {
1300 ()
1301 }
1302 }
1303 #[automatically_derived]
1304 #[doc(hidden)]
1305 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1306 for transferOwnershipReturn {
1307 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1308 Self {}
1309 }
1310 }
1311 }
1312 impl transferOwnershipReturn {
1313 fn _tokenize(
1314 &self,
1315 ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1316 ()
1317 }
1318 }
1319 #[automatically_derived]
1320 impl alloy_sol_types::SolCall for transferOwnershipCall {
1321 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1322 type Token<'a> = <Self::Parameters<
1323 'a,
1324 > as alloy_sol_types::SolType>::Token<'a>;
1325 type Return = transferOwnershipReturn;
1326 type ReturnTuple<'a> = ();
1327 type ReturnToken<'a> = <Self::ReturnTuple<
1328 'a,
1329 > as alloy_sol_types::SolType>::Token<'a>;
1330 const SIGNATURE: &'static str = "transferOwnership(address)";
1331 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
1332 #[inline]
1333 fn new<'a>(
1334 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1335 ) -> Self {
1336 tuple.into()
1337 }
1338 #[inline]
1339 fn tokenize(&self) -> Self::Token<'_> {
1340 (
1341 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1342 &self.newOwner,
1343 ),
1344 )
1345 }
1346 #[inline]
1347 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1348 transferOwnershipReturn::_tokenize(ret)
1349 }
1350 #[inline]
1351 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1352 <Self::ReturnTuple<
1353 '_,
1354 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1355 .map(Into::into)
1356 }
1357 #[inline]
1358 fn abi_decode_returns_validate(
1359 data: &[u8],
1360 ) -> alloy_sol_types::Result<Self::Return> {
1361 <Self::ReturnTuple<
1362 '_,
1363 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1364 .map(Into::into)
1365 }
1366 }
1367 };
1368 #[derive(serde::Serialize, serde::Deserialize)]
1370 #[derive()]
1371 pub enum HoprTicketPriceOracleCalls {
1372 #[allow(missing_docs)]
1373 currentTicketPrice(currentTicketPriceCall),
1374 #[allow(missing_docs)]
1375 owner(ownerCall),
1376 #[allow(missing_docs)]
1377 renounceOwnership(renounceOwnershipCall),
1378 #[allow(missing_docs)]
1379 setTicketPrice(setTicketPriceCall),
1380 #[allow(missing_docs)]
1381 transferOwnership(transferOwnershipCall),
1382 }
1383 #[automatically_derived]
1384 impl HoprTicketPriceOracleCalls {
1385 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1392 [21u8, 152u8, 22u8, 80u8],
1393 [113u8, 80u8, 24u8, 166u8],
1394 [141u8, 165u8, 203u8, 91u8],
1395 [224u8, 21u8, 145u8, 6u8],
1396 [242u8, 253u8, 227u8, 139u8],
1397 ];
1398 }
1399 #[automatically_derived]
1400 impl alloy_sol_types::SolInterface for HoprTicketPriceOracleCalls {
1401 const NAME: &'static str = "HoprTicketPriceOracleCalls";
1402 const MIN_DATA_LENGTH: usize = 0usize;
1403 const COUNT: usize = 5usize;
1404 #[inline]
1405 fn selector(&self) -> [u8; 4] {
1406 match self {
1407 Self::currentTicketPrice(_) => {
1408 <currentTicketPriceCall as alloy_sol_types::SolCall>::SELECTOR
1409 }
1410 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
1411 Self::renounceOwnership(_) => {
1412 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1413 }
1414 Self::setTicketPrice(_) => {
1415 <setTicketPriceCall as alloy_sol_types::SolCall>::SELECTOR
1416 }
1417 Self::transferOwnership(_) => {
1418 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
1419 }
1420 }
1421 }
1422 #[inline]
1423 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1424 Self::SELECTORS.get(i).copied()
1425 }
1426 #[inline]
1427 fn valid_selector(selector: [u8; 4]) -> bool {
1428 Self::SELECTORS.binary_search(&selector).is_ok()
1429 }
1430 #[inline]
1431 #[allow(non_snake_case)]
1432 fn abi_decode_raw(
1433 selector: [u8; 4],
1434 data: &[u8],
1435 ) -> alloy_sol_types::Result<Self> {
1436 static DECODE_SHIMS: &[fn(
1437 &[u8],
1438 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls>] = &[
1439 {
1440 fn setTicketPrice(
1441 data: &[u8],
1442 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls> {
1443 <setTicketPriceCall as alloy_sol_types::SolCall>::abi_decode_raw(
1444 data,
1445 )
1446 .map(HoprTicketPriceOracleCalls::setTicketPrice)
1447 }
1448 setTicketPrice
1449 },
1450 {
1451 fn renounceOwnership(
1452 data: &[u8],
1453 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls> {
1454 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
1455 data,
1456 )
1457 .map(HoprTicketPriceOracleCalls::renounceOwnership)
1458 }
1459 renounceOwnership
1460 },
1461 {
1462 fn owner(
1463 data: &[u8],
1464 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls> {
1465 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
1466 .map(HoprTicketPriceOracleCalls::owner)
1467 }
1468 owner
1469 },
1470 {
1471 fn currentTicketPrice(
1472 data: &[u8],
1473 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls> {
1474 <currentTicketPriceCall as alloy_sol_types::SolCall>::abi_decode_raw(
1475 data,
1476 )
1477 .map(HoprTicketPriceOracleCalls::currentTicketPrice)
1478 }
1479 currentTicketPrice
1480 },
1481 {
1482 fn transferOwnership(
1483 data: &[u8],
1484 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls> {
1485 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
1486 data,
1487 )
1488 .map(HoprTicketPriceOracleCalls::transferOwnership)
1489 }
1490 transferOwnership
1491 },
1492 ];
1493 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1494 return Err(
1495 alloy_sol_types::Error::unknown_selector(
1496 <Self as alloy_sol_types::SolInterface>::NAME,
1497 selector,
1498 ),
1499 );
1500 };
1501 DECODE_SHIMS[idx](data)
1502 }
1503 #[inline]
1504 #[allow(non_snake_case)]
1505 fn abi_decode_raw_validate(
1506 selector: [u8; 4],
1507 data: &[u8],
1508 ) -> alloy_sol_types::Result<Self> {
1509 static DECODE_VALIDATE_SHIMS: &[fn(
1510 &[u8],
1511 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls>] = &[
1512 {
1513 fn setTicketPrice(
1514 data: &[u8],
1515 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls> {
1516 <setTicketPriceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1517 data,
1518 )
1519 .map(HoprTicketPriceOracleCalls::setTicketPrice)
1520 }
1521 setTicketPrice
1522 },
1523 {
1524 fn renounceOwnership(
1525 data: &[u8],
1526 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls> {
1527 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1528 data,
1529 )
1530 .map(HoprTicketPriceOracleCalls::renounceOwnership)
1531 }
1532 renounceOwnership
1533 },
1534 {
1535 fn owner(
1536 data: &[u8],
1537 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls> {
1538 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1539 data,
1540 )
1541 .map(HoprTicketPriceOracleCalls::owner)
1542 }
1543 owner
1544 },
1545 {
1546 fn currentTicketPrice(
1547 data: &[u8],
1548 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls> {
1549 <currentTicketPriceCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1550 data,
1551 )
1552 .map(HoprTicketPriceOracleCalls::currentTicketPrice)
1553 }
1554 currentTicketPrice
1555 },
1556 {
1557 fn transferOwnership(
1558 data: &[u8],
1559 ) -> alloy_sol_types::Result<HoprTicketPriceOracleCalls> {
1560 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
1561 data,
1562 )
1563 .map(HoprTicketPriceOracleCalls::transferOwnership)
1564 }
1565 transferOwnership
1566 },
1567 ];
1568 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1569 return Err(
1570 alloy_sol_types::Error::unknown_selector(
1571 <Self as alloy_sol_types::SolInterface>::NAME,
1572 selector,
1573 ),
1574 );
1575 };
1576 DECODE_VALIDATE_SHIMS[idx](data)
1577 }
1578 #[inline]
1579 fn abi_encoded_size(&self) -> usize {
1580 match self {
1581 Self::currentTicketPrice(inner) => {
1582 <currentTicketPriceCall as alloy_sol_types::SolCall>::abi_encoded_size(
1583 inner,
1584 )
1585 }
1586 Self::owner(inner) => {
1587 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
1588 }
1589 Self::renounceOwnership(inner) => {
1590 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
1591 inner,
1592 )
1593 }
1594 Self::setTicketPrice(inner) => {
1595 <setTicketPriceCall as alloy_sol_types::SolCall>::abi_encoded_size(
1596 inner,
1597 )
1598 }
1599 Self::transferOwnership(inner) => {
1600 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
1601 inner,
1602 )
1603 }
1604 }
1605 }
1606 #[inline]
1607 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1608 match self {
1609 Self::currentTicketPrice(inner) => {
1610 <currentTicketPriceCall as alloy_sol_types::SolCall>::abi_encode_raw(
1611 inner,
1612 out,
1613 )
1614 }
1615 Self::owner(inner) => {
1616 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
1617 }
1618 Self::renounceOwnership(inner) => {
1619 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
1620 inner,
1621 out,
1622 )
1623 }
1624 Self::setTicketPrice(inner) => {
1625 <setTicketPriceCall as alloy_sol_types::SolCall>::abi_encode_raw(
1626 inner,
1627 out,
1628 )
1629 }
1630 Self::transferOwnership(inner) => {
1631 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
1632 inner,
1633 out,
1634 )
1635 }
1636 }
1637 }
1638 }
1639 #[derive(serde::Serialize, serde::Deserialize)]
1641 #[derive(Debug, PartialEq, Eq, Hash)]
1642 pub enum HoprTicketPriceOracleErrors {
1643 #[allow(missing_docs)]
1644 TicketPriceMustNotBeSame(TicketPriceMustNotBeSame),
1645 #[allow(missing_docs)]
1646 TicketPriceMustNotBeZero(TicketPriceMustNotBeZero),
1647 }
1648 #[automatically_derived]
1649 impl HoprTicketPriceOracleErrors {
1650 pub const SELECTORS: &'static [[u8; 4usize]] = &[
1657 [69u8, 178u8, 87u8, 239u8],
1658 [155u8, 36u8, 233u8, 57u8],
1659 ];
1660 }
1661 #[automatically_derived]
1662 impl alloy_sol_types::SolInterface for HoprTicketPriceOracleErrors {
1663 const NAME: &'static str = "HoprTicketPriceOracleErrors";
1664 const MIN_DATA_LENGTH: usize = 0usize;
1665 const COUNT: usize = 2usize;
1666 #[inline]
1667 fn selector(&self) -> [u8; 4] {
1668 match self {
1669 Self::TicketPriceMustNotBeSame(_) => {
1670 <TicketPriceMustNotBeSame as alloy_sol_types::SolError>::SELECTOR
1671 }
1672 Self::TicketPriceMustNotBeZero(_) => {
1673 <TicketPriceMustNotBeZero as alloy_sol_types::SolError>::SELECTOR
1674 }
1675 }
1676 }
1677 #[inline]
1678 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
1679 Self::SELECTORS.get(i).copied()
1680 }
1681 #[inline]
1682 fn valid_selector(selector: [u8; 4]) -> bool {
1683 Self::SELECTORS.binary_search(&selector).is_ok()
1684 }
1685 #[inline]
1686 #[allow(non_snake_case)]
1687 fn abi_decode_raw(
1688 selector: [u8; 4],
1689 data: &[u8],
1690 ) -> alloy_sol_types::Result<Self> {
1691 static DECODE_SHIMS: &[fn(
1692 &[u8],
1693 ) -> alloy_sol_types::Result<HoprTicketPriceOracleErrors>] = &[
1694 {
1695 fn TicketPriceMustNotBeZero(
1696 data: &[u8],
1697 ) -> alloy_sol_types::Result<HoprTicketPriceOracleErrors> {
1698 <TicketPriceMustNotBeZero as alloy_sol_types::SolError>::abi_decode_raw(
1699 data,
1700 )
1701 .map(HoprTicketPriceOracleErrors::TicketPriceMustNotBeZero)
1702 }
1703 TicketPriceMustNotBeZero
1704 },
1705 {
1706 fn TicketPriceMustNotBeSame(
1707 data: &[u8],
1708 ) -> alloy_sol_types::Result<HoprTicketPriceOracleErrors> {
1709 <TicketPriceMustNotBeSame as alloy_sol_types::SolError>::abi_decode_raw(
1710 data,
1711 )
1712 .map(HoprTicketPriceOracleErrors::TicketPriceMustNotBeSame)
1713 }
1714 TicketPriceMustNotBeSame
1715 },
1716 ];
1717 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1718 return Err(
1719 alloy_sol_types::Error::unknown_selector(
1720 <Self as alloy_sol_types::SolInterface>::NAME,
1721 selector,
1722 ),
1723 );
1724 };
1725 DECODE_SHIMS[idx](data)
1726 }
1727 #[inline]
1728 #[allow(non_snake_case)]
1729 fn abi_decode_raw_validate(
1730 selector: [u8; 4],
1731 data: &[u8],
1732 ) -> alloy_sol_types::Result<Self> {
1733 static DECODE_VALIDATE_SHIMS: &[fn(
1734 &[u8],
1735 ) -> alloy_sol_types::Result<HoprTicketPriceOracleErrors>] = &[
1736 {
1737 fn TicketPriceMustNotBeZero(
1738 data: &[u8],
1739 ) -> alloy_sol_types::Result<HoprTicketPriceOracleErrors> {
1740 <TicketPriceMustNotBeZero as alloy_sol_types::SolError>::abi_decode_raw_validate(
1741 data,
1742 )
1743 .map(HoprTicketPriceOracleErrors::TicketPriceMustNotBeZero)
1744 }
1745 TicketPriceMustNotBeZero
1746 },
1747 {
1748 fn TicketPriceMustNotBeSame(
1749 data: &[u8],
1750 ) -> alloy_sol_types::Result<HoprTicketPriceOracleErrors> {
1751 <TicketPriceMustNotBeSame as alloy_sol_types::SolError>::abi_decode_raw_validate(
1752 data,
1753 )
1754 .map(HoprTicketPriceOracleErrors::TicketPriceMustNotBeSame)
1755 }
1756 TicketPriceMustNotBeSame
1757 },
1758 ];
1759 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
1760 return Err(
1761 alloy_sol_types::Error::unknown_selector(
1762 <Self as alloy_sol_types::SolInterface>::NAME,
1763 selector,
1764 ),
1765 );
1766 };
1767 DECODE_VALIDATE_SHIMS[idx](data)
1768 }
1769 #[inline]
1770 fn abi_encoded_size(&self) -> usize {
1771 match self {
1772 Self::TicketPriceMustNotBeSame(inner) => {
1773 <TicketPriceMustNotBeSame as alloy_sol_types::SolError>::abi_encoded_size(
1774 inner,
1775 )
1776 }
1777 Self::TicketPriceMustNotBeZero(inner) => {
1778 <TicketPriceMustNotBeZero as alloy_sol_types::SolError>::abi_encoded_size(
1779 inner,
1780 )
1781 }
1782 }
1783 }
1784 #[inline]
1785 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
1786 match self {
1787 Self::TicketPriceMustNotBeSame(inner) => {
1788 <TicketPriceMustNotBeSame as alloy_sol_types::SolError>::abi_encode_raw(
1789 inner,
1790 out,
1791 )
1792 }
1793 Self::TicketPriceMustNotBeZero(inner) => {
1794 <TicketPriceMustNotBeZero as alloy_sol_types::SolError>::abi_encode_raw(
1795 inner,
1796 out,
1797 )
1798 }
1799 }
1800 }
1801 }
1802 #[derive(serde::Serialize, serde::Deserialize)]
1804 #[derive(Debug, PartialEq, Eq, Hash)]
1805 pub enum HoprTicketPriceOracleEvents {
1806 #[allow(missing_docs)]
1807 OwnershipTransferred(OwnershipTransferred),
1808 #[allow(missing_docs)]
1809 TicketPriceUpdated(TicketPriceUpdated),
1810 }
1811 #[automatically_derived]
1812 impl HoprTicketPriceOracleEvents {
1813 pub const SELECTORS: &'static [[u8; 32usize]] = &[
1820 [
1821 139u8, 224u8, 7u8, 156u8, 83u8, 22u8, 89u8, 20u8, 19u8, 68u8, 205u8,
1822 31u8, 208u8, 164u8, 242u8, 132u8, 25u8, 73u8, 127u8, 151u8, 34u8, 163u8,
1823 218u8, 175u8, 227u8, 180u8, 24u8, 111u8, 107u8, 100u8, 87u8, 224u8,
1824 ],
1825 [
1826 212u8, 197u8, 224u8, 107u8, 26u8, 224u8, 151u8, 186u8, 2u8, 55u8, 38u8,
1827 82u8, 167u8, 173u8, 170u8, 110u8, 74u8, 142u8, 0u8, 190u8, 82u8, 116u8,
1828 151u8, 163u8, 173u8, 14u8, 188u8, 63u8, 118u8, 30u8, 243u8, 251u8,
1829 ],
1830 ];
1831 }
1832 #[automatically_derived]
1833 impl alloy_sol_types::SolEventInterface for HoprTicketPriceOracleEvents {
1834 const NAME: &'static str = "HoprTicketPriceOracleEvents";
1835 const COUNT: usize = 2usize;
1836 fn decode_raw_log(
1837 topics: &[alloy_sol_types::Word],
1838 data: &[u8],
1839 ) -> alloy_sol_types::Result<Self> {
1840 match topics.first().copied() {
1841 Some(
1842 <OwnershipTransferred as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
1843 ) => {
1844 <OwnershipTransferred as alloy_sol_types::SolEvent>::decode_raw_log(
1845 topics,
1846 data,
1847 )
1848 .map(Self::OwnershipTransferred)
1849 }
1850 Some(
1851 <TicketPriceUpdated as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
1852 ) => {
1853 <TicketPriceUpdated as alloy_sol_types::SolEvent>::decode_raw_log(
1854 topics,
1855 data,
1856 )
1857 .map(Self::TicketPriceUpdated)
1858 }
1859 _ => {
1860 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
1861 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
1862 log: alloy_sol_types::private::Box::new(
1863 alloy_sol_types::private::LogData::new_unchecked(
1864 topics.to_vec(),
1865 data.to_vec().into(),
1866 ),
1867 ),
1868 })
1869 }
1870 }
1871 }
1872 }
1873 #[automatically_derived]
1874 impl alloy_sol_types::private::IntoLogData for HoprTicketPriceOracleEvents {
1875 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1876 match self {
1877 Self::OwnershipTransferred(inner) => {
1878 alloy_sol_types::private::IntoLogData::to_log_data(inner)
1879 }
1880 Self::TicketPriceUpdated(inner) => {
1881 alloy_sol_types::private::IntoLogData::to_log_data(inner)
1882 }
1883 }
1884 }
1885 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1886 match self {
1887 Self::OwnershipTransferred(inner) => {
1888 alloy_sol_types::private::IntoLogData::into_log_data(inner)
1889 }
1890 Self::TicketPriceUpdated(inner) => {
1891 alloy_sol_types::private::IntoLogData::into_log_data(inner)
1892 }
1893 }
1894 }
1895 }
1896 use alloy::contract as alloy_contract;
1897 #[inline]
1901 pub const fn new<
1902 P: alloy_contract::private::Provider<N>,
1903 N: alloy_contract::private::Network,
1904 >(
1905 address: alloy_sol_types::private::Address,
1906 provider: P,
1907 ) -> HoprTicketPriceOracleInstance<P, N> {
1908 HoprTicketPriceOracleInstance::<P, N>::new(address, provider)
1909 }
1910 #[inline]
1916 pub fn deploy<
1917 P: alloy_contract::private::Provider<N>,
1918 N: alloy_contract::private::Network,
1919 >(
1920 provider: P,
1921 _newOwner: alloy::sol_types::private::Address,
1922 _initialTicketPrice: alloy::sol_types::private::primitives::aliases::U256,
1923 ) -> impl ::core::future::Future<
1924 Output = alloy_contract::Result<HoprTicketPriceOracleInstance<P, N>>,
1925 > {
1926 HoprTicketPriceOracleInstance::<
1927 P,
1928 N,
1929 >::deploy(provider, _newOwner, _initialTicketPrice)
1930 }
1931 #[inline]
1937 pub fn deploy_builder<
1938 P: alloy_contract::private::Provider<N>,
1939 N: alloy_contract::private::Network,
1940 >(
1941 provider: P,
1942 _newOwner: alloy::sol_types::private::Address,
1943 _initialTicketPrice: alloy::sol_types::private::primitives::aliases::U256,
1944 ) -> alloy_contract::RawCallBuilder<P, N> {
1945 HoprTicketPriceOracleInstance::<
1946 P,
1947 N,
1948 >::deploy_builder(provider, _newOwner, _initialTicketPrice)
1949 }
1950 #[derive(Clone)]
1962 pub struct HoprTicketPriceOracleInstance<P, N = alloy_contract::private::Ethereum> {
1963 address: alloy_sol_types::private::Address,
1964 provider: P,
1965 _network: ::core::marker::PhantomData<N>,
1966 }
1967 #[automatically_derived]
1968 impl<P, N> ::core::fmt::Debug for HoprTicketPriceOracleInstance<P, N> {
1969 #[inline]
1970 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
1971 f.debug_tuple("HoprTicketPriceOracleInstance").field(&self.address).finish()
1972 }
1973 }
1974 #[automatically_derived]
1976 impl<
1977 P: alloy_contract::private::Provider<N>,
1978 N: alloy_contract::private::Network,
1979 > HoprTicketPriceOracleInstance<P, N> {
1980 #[inline]
1984 pub const fn new(
1985 address: alloy_sol_types::private::Address,
1986 provider: P,
1987 ) -> Self {
1988 Self {
1989 address,
1990 provider,
1991 _network: ::core::marker::PhantomData,
1992 }
1993 }
1994 #[inline]
2000 pub async fn deploy(
2001 provider: P,
2002 _newOwner: alloy::sol_types::private::Address,
2003 _initialTicketPrice: alloy::sol_types::private::primitives::aliases::U256,
2004 ) -> alloy_contract::Result<HoprTicketPriceOracleInstance<P, N>> {
2005 let call_builder = Self::deploy_builder(
2006 provider,
2007 _newOwner,
2008 _initialTicketPrice,
2009 );
2010 let contract_address = call_builder.deploy().await?;
2011 Ok(Self::new(contract_address, call_builder.provider))
2012 }
2013 #[inline]
2019 pub fn deploy_builder(
2020 provider: P,
2021 _newOwner: alloy::sol_types::private::Address,
2022 _initialTicketPrice: alloy::sol_types::private::primitives::aliases::U256,
2023 ) -> alloy_contract::RawCallBuilder<P, N> {
2024 alloy_contract::RawCallBuilder::new_raw_deploy(
2025 provider,
2026 [
2027 &BYTECODE[..],
2028 &alloy_sol_types::SolConstructor::abi_encode(
2029 &constructorCall {
2030 _newOwner,
2031 _initialTicketPrice,
2032 },
2033 )[..],
2034 ]
2035 .concat()
2036 .into(),
2037 )
2038 }
2039 #[inline]
2041 pub const fn address(&self) -> &alloy_sol_types::private::Address {
2042 &self.address
2043 }
2044 #[inline]
2046 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
2047 self.address = address;
2048 }
2049 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
2051 self.set_address(address);
2052 self
2053 }
2054 #[inline]
2056 pub const fn provider(&self) -> &P {
2057 &self.provider
2058 }
2059 }
2060 impl<P: ::core::clone::Clone, N> HoprTicketPriceOracleInstance<&P, N> {
2061 #[inline]
2063 pub fn with_cloned_provider(self) -> HoprTicketPriceOracleInstance<P, N> {
2064 HoprTicketPriceOracleInstance {
2065 address: self.address,
2066 provider: ::core::clone::Clone::clone(&self.provider),
2067 _network: ::core::marker::PhantomData,
2068 }
2069 }
2070 }
2071 #[automatically_derived]
2073 impl<
2074 P: alloy_contract::private::Provider<N>,
2075 N: alloy_contract::private::Network,
2076 > HoprTicketPriceOracleInstance<P, N> {
2077 pub fn call_builder<C: alloy_sol_types::SolCall>(
2082 &self,
2083 call: &C,
2084 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
2085 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
2086 }
2087 pub fn currentTicketPrice(
2089 &self,
2090 ) -> alloy_contract::SolCallBuilder<&P, currentTicketPriceCall, N> {
2091 self.call_builder(¤tTicketPriceCall)
2092 }
2093 pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
2095 self.call_builder(&ownerCall)
2096 }
2097 pub fn renounceOwnership(
2099 &self,
2100 ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
2101 self.call_builder(&renounceOwnershipCall)
2102 }
2103 pub fn setTicketPrice(
2105 &self,
2106 _newTicketPrice: alloy::sol_types::private::primitives::aliases::U256,
2107 ) -> alloy_contract::SolCallBuilder<&P, setTicketPriceCall, N> {
2108 self.call_builder(
2109 &setTicketPriceCall {
2110 _newTicketPrice,
2111 },
2112 )
2113 }
2114 pub fn transferOwnership(
2116 &self,
2117 newOwner: alloy::sol_types::private::Address,
2118 ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
2119 self.call_builder(&transferOwnershipCall { newOwner })
2120 }
2121 }
2122 #[automatically_derived]
2124 impl<
2125 P: alloy_contract::private::Provider<N>,
2126 N: alloy_contract::private::Network,
2127 > HoprTicketPriceOracleInstance<P, N> {
2128 pub fn event_filter<E: alloy_sol_types::SolEvent>(
2133 &self,
2134 ) -> alloy_contract::Event<&P, E, N> {
2135 alloy_contract::Event::new_sol(&self.provider, &self.address)
2136 }
2137 pub fn OwnershipTransferred_filter(
2139 &self,
2140 ) -> alloy_contract::Event<&P, OwnershipTransferred, N> {
2141 self.event_filter::<OwnershipTransferred>()
2142 }
2143 pub fn TicketPriceUpdated_filter(
2145 &self,
2146 ) -> alloy_contract::Event<&P, TicketPriceUpdated, N> {
2147 self.event_filter::<TicketPriceUpdated>()
2148 }
2149 }
2150}