1#[allow(
348 non_camel_case_types,
349 non_snake_case,
350 clippy::pub_underscore_fields,
351 clippy::style,
352 clippy::empty_structs_with_brackets
353)]
354pub mod IApplication {
355 use super::*;
356 use alloy::sol_types as alloy_sol_types;
357 #[rustfmt::skip]
363 #[allow(clippy::all)]
364 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
365 b"",
366 );
367 #[rustfmt::skip]
373 #[allow(clippy::all)]
374 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
375 b"",
376 );
377 #[derive(serde::Serialize, serde::Deserialize)]
378 #[derive(Default, Debug, PartialEq, Eq, Hash)]
379 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
383 #[derive(Clone)]
384 pub struct OutputValidityProof {
385 #[allow(missing_docs)]
386 pub outputIndex: u64,
387 #[allow(missing_docs)]
388 pub outputHashesSiblings: alloy::sol_types::private::Vec<
389 alloy::sol_types::private::FixedBytes<32>,
390 >,
391 }
392 #[allow(
393 non_camel_case_types,
394 non_snake_case,
395 clippy::pub_underscore_fields,
396 clippy::style
397 )]
398 const _: () = {
399 use alloy::sol_types as alloy_sol_types;
400 #[doc(hidden)]
401 #[allow(dead_code)]
402 type UnderlyingSolTuple<'a> = (
403 alloy::sol_types::sol_data::Uint<64>,
404 alloy::sol_types::sol_data::Array<alloy::sol_types::sol_data::FixedBytes<32>>,
405 );
406 #[doc(hidden)]
407 type UnderlyingRustTuple<'a> = (
408 u64,
409 alloy::sol_types::private::Vec<alloy::sol_types::private::FixedBytes<32>>,
410 );
411 #[cfg(test)]
412 #[allow(dead_code, unreachable_patterns)]
413 fn _type_assertion(
414 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
415 ) {
416 match _t {
417 alloy_sol_types::private::AssertTypeEq::<
418 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
419 >(_) => {}
420 }
421 }
422 #[automatically_derived]
423 #[doc(hidden)]
424 impl ::core::convert::From<OutputValidityProof> for UnderlyingRustTuple<'_> {
425 fn from(value: OutputValidityProof) -> Self {
426 (value.outputIndex, value.outputHashesSiblings)
427 }
428 }
429 #[automatically_derived]
430 #[doc(hidden)]
431 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OutputValidityProof {
432 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
433 Self {
434 outputIndex: tuple.0,
435 outputHashesSiblings: tuple.1,
436 }
437 }
438 }
439 #[automatically_derived]
440 impl alloy_sol_types::SolValue for OutputValidityProof {
441 type SolType = Self;
442 }
443 #[automatically_derived]
444 impl alloy_sol_types::private::SolTypeValue<Self> for OutputValidityProof {
445 #[inline]
446 fn stv_to_tokens(&self) -> <Self as alloy_sol_types::SolType>::Token<'_> {
447 (
448 <alloy::sol_types::sol_data::Uint<
449 64,
450 > as alloy_sol_types::SolType>::tokenize(&self.outputIndex),
451 <alloy::sol_types::sol_data::Array<
452 alloy::sol_types::sol_data::FixedBytes<32>,
453 > as alloy_sol_types::SolType>::tokenize(&self.outputHashesSiblings),
454 )
455 }
456 #[inline]
457 fn stv_abi_encoded_size(&self) -> usize {
458 if let Some(size) = <Self as alloy_sol_types::SolType>::ENCODED_SIZE {
459 return size;
460 }
461 let tuple = <UnderlyingRustTuple<
462 '_,
463 > as ::core::convert::From<Self>>::from(self.clone());
464 <UnderlyingSolTuple<
465 '_,
466 > as alloy_sol_types::SolType>::abi_encoded_size(&tuple)
467 }
468 #[inline]
469 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
470 <Self as alloy_sol_types::SolStruct>::eip712_hash_struct(self)
471 }
472 #[inline]
473 fn stv_abi_encode_packed_to(
474 &self,
475 out: &mut alloy_sol_types::private::Vec<u8>,
476 ) {
477 let tuple = <UnderlyingRustTuple<
478 '_,
479 > as ::core::convert::From<Self>>::from(self.clone());
480 <UnderlyingSolTuple<
481 '_,
482 > as alloy_sol_types::SolType>::abi_encode_packed_to(&tuple, out)
483 }
484 #[inline]
485 fn stv_abi_packed_encoded_size(&self) -> usize {
486 if let Some(size) = <Self as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE {
487 return size;
488 }
489 let tuple = <UnderlyingRustTuple<
490 '_,
491 > as ::core::convert::From<Self>>::from(self.clone());
492 <UnderlyingSolTuple<
493 '_,
494 > as alloy_sol_types::SolType>::abi_packed_encoded_size(&tuple)
495 }
496 }
497 #[automatically_derived]
498 impl alloy_sol_types::SolType for OutputValidityProof {
499 type RustType = Self;
500 type Token<'a> = <UnderlyingSolTuple<
501 'a,
502 > as alloy_sol_types::SolType>::Token<'a>;
503 const SOL_NAME: &'static str = <Self as alloy_sol_types::SolStruct>::NAME;
504 const ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
505 '_,
506 > as alloy_sol_types::SolType>::ENCODED_SIZE;
507 const PACKED_ENCODED_SIZE: Option<usize> = <UnderlyingSolTuple<
508 '_,
509 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
510 #[inline]
511 fn valid_token(token: &Self::Token<'_>) -> bool {
512 <UnderlyingSolTuple<'_> as alloy_sol_types::SolType>::valid_token(token)
513 }
514 #[inline]
515 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
516 let tuple = <UnderlyingSolTuple<
517 '_,
518 > as alloy_sol_types::SolType>::detokenize(token);
519 <Self as ::core::convert::From<UnderlyingRustTuple<'_>>>::from(tuple)
520 }
521 }
522 #[automatically_derived]
523 impl alloy_sol_types::SolStruct for OutputValidityProof {
524 const NAME: &'static str = "OutputValidityProof";
525 #[inline]
526 fn eip712_root_type() -> alloy_sol_types::private::Cow<'static, str> {
527 alloy_sol_types::private::Cow::Borrowed(
528 "OutputValidityProof(uint64 outputIndex,bytes32[] outputHashesSiblings)",
529 )
530 }
531 #[inline]
532 fn eip712_components() -> alloy_sol_types::private::Vec<
533 alloy_sol_types::private::Cow<'static, str>,
534 > {
535 alloy_sol_types::private::Vec::new()
536 }
537 #[inline]
538 fn eip712_encode_type() -> alloy_sol_types::private::Cow<'static, str> {
539 <Self as alloy_sol_types::SolStruct>::eip712_root_type()
540 }
541 #[inline]
542 fn eip712_encode_data(&self) -> alloy_sol_types::private::Vec<u8> {
543 [
544 <alloy::sol_types::sol_data::Uint<
545 64,
546 > as alloy_sol_types::SolType>::eip712_data_word(&self.outputIndex)
547 .0,
548 <alloy::sol_types::sol_data::Array<
549 alloy::sol_types::sol_data::FixedBytes<32>,
550 > as alloy_sol_types::SolType>::eip712_data_word(
551 &self.outputHashesSiblings,
552 )
553 .0,
554 ]
555 .concat()
556 }
557 }
558 #[automatically_derived]
559 impl alloy_sol_types::EventTopic for OutputValidityProof {
560 #[inline]
561 fn topic_preimage_length(rust: &Self::RustType) -> usize {
562 0usize
563 + <alloy::sol_types::sol_data::Uint<
564 64,
565 > as alloy_sol_types::EventTopic>::topic_preimage_length(
566 &rust.outputIndex,
567 )
568 + <alloy::sol_types::sol_data::Array<
569 alloy::sol_types::sol_data::FixedBytes<32>,
570 > as alloy_sol_types::EventTopic>::topic_preimage_length(
571 &rust.outputHashesSiblings,
572 )
573 }
574 #[inline]
575 fn encode_topic_preimage(
576 rust: &Self::RustType,
577 out: &mut alloy_sol_types::private::Vec<u8>,
578 ) {
579 out.reserve(
580 <Self as alloy_sol_types::EventTopic>::topic_preimage_length(rust),
581 );
582 <alloy::sol_types::sol_data::Uint<
583 64,
584 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
585 &rust.outputIndex,
586 out,
587 );
588 <alloy::sol_types::sol_data::Array<
589 alloy::sol_types::sol_data::FixedBytes<32>,
590 > as alloy_sol_types::EventTopic>::encode_topic_preimage(
591 &rust.outputHashesSiblings,
592 out,
593 );
594 }
595 #[inline]
596 fn encode_topic(
597 rust: &Self::RustType,
598 ) -> alloy_sol_types::abi::token::WordToken {
599 let mut out = alloy_sol_types::private::Vec::new();
600 <Self as alloy_sol_types::EventTopic>::encode_topic_preimage(
601 rust,
602 &mut out,
603 );
604 alloy_sol_types::abi::token::WordToken(
605 alloy_sol_types::private::keccak256(out),
606 )
607 }
608 }
609 };
610 #[derive(serde::Serialize, serde::Deserialize)]
611 #[derive(Default, Debug, PartialEq, Eq, Hash)]
612 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
617 #[derive(Clone)]
618 pub struct InsufficientFunds {
619 #[allow(missing_docs)]
620 pub value: alloy::sol_types::private::primitives::aliases::U256,
621 #[allow(missing_docs)]
622 pub balance: alloy::sol_types::private::primitives::aliases::U256,
623 }
624 #[allow(
625 non_camel_case_types,
626 non_snake_case,
627 clippy::pub_underscore_fields,
628 clippy::style
629 )]
630 const _: () = {
631 use alloy::sol_types as alloy_sol_types;
632 #[doc(hidden)]
633 #[allow(dead_code)]
634 type UnderlyingSolTuple<'a> = (
635 alloy::sol_types::sol_data::Uint<256>,
636 alloy::sol_types::sol_data::Uint<256>,
637 );
638 #[doc(hidden)]
639 type UnderlyingRustTuple<'a> = (
640 alloy::sol_types::private::primitives::aliases::U256,
641 alloy::sol_types::private::primitives::aliases::U256,
642 );
643 #[cfg(test)]
644 #[allow(dead_code, unreachable_patterns)]
645 fn _type_assertion(
646 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
647 ) {
648 match _t {
649 alloy_sol_types::private::AssertTypeEq::<
650 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
651 >(_) => {}
652 }
653 }
654 #[automatically_derived]
655 #[doc(hidden)]
656 impl ::core::convert::From<InsufficientFunds> for UnderlyingRustTuple<'_> {
657 fn from(value: InsufficientFunds) -> Self {
658 (value.value, value.balance)
659 }
660 }
661 #[automatically_derived]
662 #[doc(hidden)]
663 impl ::core::convert::From<UnderlyingRustTuple<'_>> for InsufficientFunds {
664 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
665 Self {
666 value: tuple.0,
667 balance: tuple.1,
668 }
669 }
670 }
671 #[automatically_derived]
672 impl alloy_sol_types::SolError for InsufficientFunds {
673 type Parameters<'a> = UnderlyingSolTuple<'a>;
674 type Token<'a> = <Self::Parameters<
675 'a,
676 > as alloy_sol_types::SolType>::Token<'a>;
677 const SIGNATURE: &'static str = "InsufficientFunds(uint256,uint256)";
678 const SELECTOR: [u8; 4] = [3u8, 235u8, 139u8, 84u8];
679 #[inline]
680 fn new<'a>(
681 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
682 ) -> Self {
683 tuple.into()
684 }
685 #[inline]
686 fn tokenize(&self) -> Self::Token<'_> {
687 (
688 <alloy::sol_types::sol_data::Uint<
689 256,
690 > as alloy_sol_types::SolType>::tokenize(&self.value),
691 <alloy::sol_types::sol_data::Uint<
692 256,
693 > as alloy_sol_types::SolType>::tokenize(&self.balance),
694 )
695 }
696 #[inline]
697 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
698 <Self::Parameters<
699 '_,
700 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
701 .map(Self::new)
702 }
703 }
704 };
705 #[derive(serde::Serialize, serde::Deserialize)]
706 #[derive(Default, Debug, PartialEq, Eq, Hash)]
707 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
712 #[derive(Clone)]
713 pub struct InvalidOutputHashesSiblingsArrayLength;
714 #[allow(
715 non_camel_case_types,
716 non_snake_case,
717 clippy::pub_underscore_fields,
718 clippy::style
719 )]
720 const _: () = {
721 use alloy::sol_types as alloy_sol_types;
722 #[doc(hidden)]
723 #[allow(dead_code)]
724 type UnderlyingSolTuple<'a> = ();
725 #[doc(hidden)]
726 type UnderlyingRustTuple<'a> = ();
727 #[cfg(test)]
728 #[allow(dead_code, unreachable_patterns)]
729 fn _type_assertion(
730 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
731 ) {
732 match _t {
733 alloy_sol_types::private::AssertTypeEq::<
734 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
735 >(_) => {}
736 }
737 }
738 #[automatically_derived]
739 #[doc(hidden)]
740 impl ::core::convert::From<InvalidOutputHashesSiblingsArrayLength>
741 for UnderlyingRustTuple<'_> {
742 fn from(value: InvalidOutputHashesSiblingsArrayLength) -> Self {
743 ()
744 }
745 }
746 #[automatically_derived]
747 #[doc(hidden)]
748 impl ::core::convert::From<UnderlyingRustTuple<'_>>
749 for InvalidOutputHashesSiblingsArrayLength {
750 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
751 Self
752 }
753 }
754 #[automatically_derived]
755 impl alloy_sol_types::SolError for InvalidOutputHashesSiblingsArrayLength {
756 type Parameters<'a> = UnderlyingSolTuple<'a>;
757 type Token<'a> = <Self::Parameters<
758 'a,
759 > as alloy_sol_types::SolType>::Token<'a>;
760 const SIGNATURE: &'static str = "InvalidOutputHashesSiblingsArrayLength()";
761 const SELECTOR: [u8; 4] = [186u8, 88u8, 189u8, 54u8];
762 #[inline]
763 fn new<'a>(
764 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
765 ) -> Self {
766 tuple.into()
767 }
768 #[inline]
769 fn tokenize(&self) -> Self::Token<'_> {
770 ()
771 }
772 #[inline]
773 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
774 <Self::Parameters<
775 '_,
776 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
777 .map(Self::new)
778 }
779 }
780 };
781 #[derive(serde::Serialize, serde::Deserialize)]
782 #[derive(Default, Debug, PartialEq, Eq, Hash)]
783 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
788 #[derive(Clone)]
789 pub struct InvalidOutputsMerkleRoot {
790 #[allow(missing_docs)]
791 pub outputsMerkleRoot: alloy::sol_types::private::FixedBytes<32>,
792 }
793 #[allow(
794 non_camel_case_types,
795 non_snake_case,
796 clippy::pub_underscore_fields,
797 clippy::style
798 )]
799 const _: () = {
800 use alloy::sol_types as alloy_sol_types;
801 #[doc(hidden)]
802 #[allow(dead_code)]
803 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
804 #[doc(hidden)]
805 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
806 #[cfg(test)]
807 #[allow(dead_code, unreachable_patterns)]
808 fn _type_assertion(
809 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
810 ) {
811 match _t {
812 alloy_sol_types::private::AssertTypeEq::<
813 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
814 >(_) => {}
815 }
816 }
817 #[automatically_derived]
818 #[doc(hidden)]
819 impl ::core::convert::From<InvalidOutputsMerkleRoot>
820 for UnderlyingRustTuple<'_> {
821 fn from(value: InvalidOutputsMerkleRoot) -> Self {
822 (value.outputsMerkleRoot,)
823 }
824 }
825 #[automatically_derived]
826 #[doc(hidden)]
827 impl ::core::convert::From<UnderlyingRustTuple<'_>>
828 for InvalidOutputsMerkleRoot {
829 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
830 Self { outputsMerkleRoot: tuple.0 }
831 }
832 }
833 #[automatically_derived]
834 impl alloy_sol_types::SolError for InvalidOutputsMerkleRoot {
835 type Parameters<'a> = UnderlyingSolTuple<'a>;
836 type Token<'a> = <Self::Parameters<
837 'a,
838 > as alloy_sol_types::SolType>::Token<'a>;
839 const SIGNATURE: &'static str = "InvalidOutputsMerkleRoot(bytes32)";
840 const SELECTOR: [u8; 4] = [68u8, 161u8, 146u8, 255u8];
841 #[inline]
842 fn new<'a>(
843 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
844 ) -> Self {
845 tuple.into()
846 }
847 #[inline]
848 fn tokenize(&self) -> Self::Token<'_> {
849 (
850 <alloy::sol_types::sol_data::FixedBytes<
851 32,
852 > as alloy_sol_types::SolType>::tokenize(&self.outputsMerkleRoot),
853 )
854 }
855 #[inline]
856 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
857 <Self::Parameters<
858 '_,
859 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
860 .map(Self::new)
861 }
862 }
863 };
864 #[derive(serde::Serialize, serde::Deserialize)]
865 #[derive(Default, Debug, PartialEq, Eq, Hash)]
866 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
871 #[derive(Clone)]
872 pub struct OutputNotExecutable {
873 #[allow(missing_docs)]
874 pub output: alloy::sol_types::private::Bytes,
875 }
876 #[allow(
877 non_camel_case_types,
878 non_snake_case,
879 clippy::pub_underscore_fields,
880 clippy::style
881 )]
882 const _: () = {
883 use alloy::sol_types as alloy_sol_types;
884 #[doc(hidden)]
885 #[allow(dead_code)]
886 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,);
887 #[doc(hidden)]
888 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,);
889 #[cfg(test)]
890 #[allow(dead_code, unreachable_patterns)]
891 fn _type_assertion(
892 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
893 ) {
894 match _t {
895 alloy_sol_types::private::AssertTypeEq::<
896 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
897 >(_) => {}
898 }
899 }
900 #[automatically_derived]
901 #[doc(hidden)]
902 impl ::core::convert::From<OutputNotExecutable> for UnderlyingRustTuple<'_> {
903 fn from(value: OutputNotExecutable) -> Self {
904 (value.output,)
905 }
906 }
907 #[automatically_derived]
908 #[doc(hidden)]
909 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OutputNotExecutable {
910 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
911 Self { output: tuple.0 }
912 }
913 }
914 #[automatically_derived]
915 impl alloy_sol_types::SolError for OutputNotExecutable {
916 type Parameters<'a> = UnderlyingSolTuple<'a>;
917 type Token<'a> = <Self::Parameters<
918 'a,
919 > as alloy_sol_types::SolType>::Token<'a>;
920 const SIGNATURE: &'static str = "OutputNotExecutable(bytes)";
921 const SELECTOR: [u8; 4] = [210u8, 132u8, 192u8, 30u8];
922 #[inline]
923 fn new<'a>(
924 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
925 ) -> Self {
926 tuple.into()
927 }
928 #[inline]
929 fn tokenize(&self) -> Self::Token<'_> {
930 (
931 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
932 &self.output,
933 ),
934 )
935 }
936 #[inline]
937 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
938 <Self::Parameters<
939 '_,
940 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
941 .map(Self::new)
942 }
943 }
944 };
945 #[derive(serde::Serialize, serde::Deserialize)]
946 #[derive(Default, Debug, PartialEq, Eq, Hash)]
947 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
952 #[derive(Clone)]
953 pub struct OutputNotReexecutable {
954 #[allow(missing_docs)]
955 pub output: alloy::sol_types::private::Bytes,
956 }
957 #[allow(
958 non_camel_case_types,
959 non_snake_case,
960 clippy::pub_underscore_fields,
961 clippy::style
962 )]
963 const _: () = {
964 use alloy::sol_types as alloy_sol_types;
965 #[doc(hidden)]
966 #[allow(dead_code)]
967 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,);
968 #[doc(hidden)]
969 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,);
970 #[cfg(test)]
971 #[allow(dead_code, unreachable_patterns)]
972 fn _type_assertion(
973 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
974 ) {
975 match _t {
976 alloy_sol_types::private::AssertTypeEq::<
977 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
978 >(_) => {}
979 }
980 }
981 #[automatically_derived]
982 #[doc(hidden)]
983 impl ::core::convert::From<OutputNotReexecutable> for UnderlyingRustTuple<'_> {
984 fn from(value: OutputNotReexecutable) -> Self {
985 (value.output,)
986 }
987 }
988 #[automatically_derived]
989 #[doc(hidden)]
990 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OutputNotReexecutable {
991 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
992 Self { output: tuple.0 }
993 }
994 }
995 #[automatically_derived]
996 impl alloy_sol_types::SolError for OutputNotReexecutable {
997 type Parameters<'a> = UnderlyingSolTuple<'a>;
998 type Token<'a> = <Self::Parameters<
999 'a,
1000 > as alloy_sol_types::SolType>::Token<'a>;
1001 const SIGNATURE: &'static str = "OutputNotReexecutable(bytes)";
1002 const SELECTOR: [u8; 4] = [123u8, 151u8, 166u8, 187u8];
1003 #[inline]
1004 fn new<'a>(
1005 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1006 ) -> Self {
1007 tuple.into()
1008 }
1009 #[inline]
1010 fn tokenize(&self) -> Self::Token<'_> {
1011 (
1012 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1013 &self.output,
1014 ),
1015 )
1016 }
1017 #[inline]
1018 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1019 <Self::Parameters<
1020 '_,
1021 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1022 .map(Self::new)
1023 }
1024 }
1025 };
1026 #[derive(serde::Serialize, serde::Deserialize)]
1027 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1028 #[allow(
1033 non_camel_case_types,
1034 non_snake_case,
1035 clippy::pub_underscore_fields,
1036 clippy::style
1037 )]
1038 #[derive(Clone)]
1039 pub struct OutputExecuted {
1040 #[allow(missing_docs)]
1041 pub outputIndex: u64,
1042 #[allow(missing_docs)]
1043 pub output: alloy::sol_types::private::Bytes,
1044 }
1045 #[allow(
1046 non_camel_case_types,
1047 non_snake_case,
1048 clippy::pub_underscore_fields,
1049 clippy::style
1050 )]
1051 const _: () = {
1052 use alloy::sol_types as alloy_sol_types;
1053 #[automatically_derived]
1054 impl alloy_sol_types::SolEvent for OutputExecuted {
1055 type DataTuple<'a> = (
1056 alloy::sol_types::sol_data::Uint<64>,
1057 alloy::sol_types::sol_data::Bytes,
1058 );
1059 type DataToken<'a> = <Self::DataTuple<
1060 'a,
1061 > as alloy_sol_types::SolType>::Token<'a>;
1062 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1063 const SIGNATURE: &'static str = "OutputExecuted(uint64,bytes)";
1064 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1065 202u8, 209u8, 243u8, 97u8, 198u8, 232u8, 70u8, 100u8, 232u8, 146u8, 35u8,
1066 2u8, 145u8, 200u8, 232u8, 235u8, 149u8, 85u8, 104u8, 62u8, 10u8, 106u8,
1067 92u8, 232u8, 234u8, 123u8, 32u8, 74u8, 192u8, 172u8, 54u8, 118u8,
1068 ]);
1069 const ANONYMOUS: bool = false;
1070 #[allow(unused_variables)]
1071 #[inline]
1072 fn new(
1073 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1074 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1075 ) -> Self {
1076 Self {
1077 outputIndex: data.0,
1078 output: data.1,
1079 }
1080 }
1081 #[inline]
1082 fn check_signature(
1083 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1084 ) -> alloy_sol_types::Result<()> {
1085 if topics.0 != Self::SIGNATURE_HASH {
1086 return Err(
1087 alloy_sol_types::Error::invalid_event_signature_hash(
1088 Self::SIGNATURE,
1089 topics.0,
1090 Self::SIGNATURE_HASH,
1091 ),
1092 );
1093 }
1094 Ok(())
1095 }
1096 #[inline]
1097 fn tokenize_body(&self) -> Self::DataToken<'_> {
1098 (
1099 <alloy::sol_types::sol_data::Uint<
1100 64,
1101 > as alloy_sol_types::SolType>::tokenize(&self.outputIndex),
1102 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1103 &self.output,
1104 ),
1105 )
1106 }
1107 #[inline]
1108 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1109 (Self::SIGNATURE_HASH.into(),)
1110 }
1111 #[inline]
1112 fn encode_topics_raw(
1113 &self,
1114 out: &mut [alloy_sol_types::abi::token::WordToken],
1115 ) -> alloy_sol_types::Result<()> {
1116 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1117 return Err(alloy_sol_types::Error::Overrun);
1118 }
1119 out[0usize] = alloy_sol_types::abi::token::WordToken(
1120 Self::SIGNATURE_HASH,
1121 );
1122 Ok(())
1123 }
1124 }
1125 #[automatically_derived]
1126 impl alloy_sol_types::private::IntoLogData for OutputExecuted {
1127 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1128 From::from(self)
1129 }
1130 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1131 From::from(&self)
1132 }
1133 }
1134 #[automatically_derived]
1135 impl From<&OutputExecuted> for alloy_sol_types::private::LogData {
1136 #[inline]
1137 fn from(this: &OutputExecuted) -> alloy_sol_types::private::LogData {
1138 alloy_sol_types::SolEvent::encode_log_data(this)
1139 }
1140 }
1141 };
1142 #[derive(serde::Serialize, serde::Deserialize)]
1143 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1144 #[allow(
1149 non_camel_case_types,
1150 non_snake_case,
1151 clippy::pub_underscore_fields,
1152 clippy::style
1153 )]
1154 #[derive(Clone)]
1155 pub struct OutputsMerkleRootValidatorChanged {
1156 #[allow(missing_docs)]
1157 pub newOutputsMerkleRootValidator: 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 #[automatically_derived]
1168 impl alloy_sol_types::SolEvent for OutputsMerkleRootValidatorChanged {
1169 type DataTuple<'a> = (alloy::sol_types::sol_data::Address,);
1170 type DataToken<'a> = <Self::DataTuple<
1171 'a,
1172 > as alloy_sol_types::SolType>::Token<'a>;
1173 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
1174 const SIGNATURE: &'static str = "OutputsMerkleRootValidatorChanged(address)";
1175 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1176 106u8, 211u8, 24u8, 139u8, 168u8, 244u8, 48u8, 251u8, 160u8, 101u8,
1177 108u8, 176u8, 167u8, 232u8, 57u8, 171u8, 32u8, 32u8, 213u8, 88u8, 107u8,
1178 161u8, 26u8, 20u8, 119u8, 209u8, 143u8, 112u8, 146u8, 248u8, 190u8, 206u8,
1179 ]);
1180 const ANONYMOUS: bool = false;
1181 #[allow(unused_variables)]
1182 #[inline]
1183 fn new(
1184 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1185 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1186 ) -> Self {
1187 Self {
1188 newOutputsMerkleRootValidator: data.0,
1189 }
1190 }
1191 #[inline]
1192 fn check_signature(
1193 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
1194 ) -> alloy_sol_types::Result<()> {
1195 if topics.0 != Self::SIGNATURE_HASH {
1196 return Err(
1197 alloy_sol_types::Error::invalid_event_signature_hash(
1198 Self::SIGNATURE,
1199 topics.0,
1200 Self::SIGNATURE_HASH,
1201 ),
1202 );
1203 }
1204 Ok(())
1205 }
1206 #[inline]
1207 fn tokenize_body(&self) -> Self::DataToken<'_> {
1208 (
1209 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1210 &self.newOutputsMerkleRootValidator,
1211 ),
1212 )
1213 }
1214 #[inline]
1215 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1216 (Self::SIGNATURE_HASH.into(),)
1217 }
1218 #[inline]
1219 fn encode_topics_raw(
1220 &self,
1221 out: &mut [alloy_sol_types::abi::token::WordToken],
1222 ) -> alloy_sol_types::Result<()> {
1223 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1224 return Err(alloy_sol_types::Error::Overrun);
1225 }
1226 out[0usize] = alloy_sol_types::abi::token::WordToken(
1227 Self::SIGNATURE_HASH,
1228 );
1229 Ok(())
1230 }
1231 }
1232 #[automatically_derived]
1233 impl alloy_sol_types::private::IntoLogData
1234 for OutputsMerkleRootValidatorChanged {
1235 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1236 From::from(self)
1237 }
1238 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1239 From::from(&self)
1240 }
1241 }
1242 #[automatically_derived]
1243 impl From<&OutputsMerkleRootValidatorChanged>
1244 for alloy_sol_types::private::LogData {
1245 #[inline]
1246 fn from(
1247 this: &OutputsMerkleRootValidatorChanged,
1248 ) -> alloy_sol_types::private::LogData {
1249 alloy_sol_types::SolEvent::encode_log_data(this)
1250 }
1251 }
1252 };
1253 #[derive(serde::Serialize, serde::Deserialize)]
1254 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1255 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1260 #[derive(Clone)]
1261 pub struct executeOutputCall {
1262 #[allow(missing_docs)]
1263 pub output: alloy::sol_types::private::Bytes,
1264 #[allow(missing_docs)]
1265 pub proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
1266 }
1267 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1269 #[derive(Clone)]
1270 pub struct executeOutputReturn {}
1271 #[allow(
1272 non_camel_case_types,
1273 non_snake_case,
1274 clippy::pub_underscore_fields,
1275 clippy::style
1276 )]
1277 const _: () = {
1278 use alloy::sol_types as alloy_sol_types;
1279 {
1280 #[doc(hidden)]
1281 #[allow(dead_code)]
1282 type UnderlyingSolTuple<'a> = (
1283 alloy::sol_types::sol_data::Bytes,
1284 OutputValidityProof,
1285 );
1286 #[doc(hidden)]
1287 type UnderlyingRustTuple<'a> = (
1288 alloy::sol_types::private::Bytes,
1289 <OutputValidityProof as alloy::sol_types::SolType>::RustType,
1290 );
1291 #[cfg(test)]
1292 #[allow(dead_code, unreachable_patterns)]
1293 fn _type_assertion(
1294 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1295 ) {
1296 match _t {
1297 alloy_sol_types::private::AssertTypeEq::<
1298 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1299 >(_) => {}
1300 }
1301 }
1302 #[automatically_derived]
1303 #[doc(hidden)]
1304 impl ::core::convert::From<executeOutputCall> for UnderlyingRustTuple<'_> {
1305 fn from(value: executeOutputCall) -> Self {
1306 (value.output, value.proof)
1307 }
1308 }
1309 #[automatically_derived]
1310 #[doc(hidden)]
1311 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeOutputCall {
1312 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1313 Self {
1314 output: tuple.0,
1315 proof: tuple.1,
1316 }
1317 }
1318 }
1319 }
1320 {
1321 #[doc(hidden)]
1322 #[allow(dead_code)]
1323 type UnderlyingSolTuple<'a> = ();
1324 #[doc(hidden)]
1325 type UnderlyingRustTuple<'a> = ();
1326 #[cfg(test)]
1327 #[allow(dead_code, unreachable_patterns)]
1328 fn _type_assertion(
1329 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1330 ) {
1331 match _t {
1332 alloy_sol_types::private::AssertTypeEq::<
1333 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1334 >(_) => {}
1335 }
1336 }
1337 #[automatically_derived]
1338 #[doc(hidden)]
1339 impl ::core::convert::From<executeOutputReturn> for UnderlyingRustTuple<'_> {
1340 fn from(value: executeOutputReturn) -> Self {
1341 ()
1342 }
1343 }
1344 #[automatically_derived]
1345 #[doc(hidden)]
1346 impl ::core::convert::From<UnderlyingRustTuple<'_>> for executeOutputReturn {
1347 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1348 Self {}
1349 }
1350 }
1351 }
1352 impl executeOutputReturn {
1353 fn _tokenize(
1354 &self,
1355 ) -> <executeOutputCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
1356 ()
1357 }
1358 }
1359 #[automatically_derived]
1360 impl alloy_sol_types::SolCall for executeOutputCall {
1361 type Parameters<'a> = (
1362 alloy::sol_types::sol_data::Bytes,
1363 OutputValidityProof,
1364 );
1365 type Token<'a> = <Self::Parameters<
1366 'a,
1367 > as alloy_sol_types::SolType>::Token<'a>;
1368 type Return = executeOutputReturn;
1369 type ReturnTuple<'a> = ();
1370 type ReturnToken<'a> = <Self::ReturnTuple<
1371 'a,
1372 > as alloy_sol_types::SolType>::Token<'a>;
1373 const SIGNATURE: &'static str = "executeOutput(bytes,(uint64,bytes32[]))";
1374 const SELECTOR: [u8; 4] = [51u8, 19u8, 123u8, 118u8];
1375 #[inline]
1376 fn new<'a>(
1377 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1378 ) -> Self {
1379 tuple.into()
1380 }
1381 #[inline]
1382 fn tokenize(&self) -> Self::Token<'_> {
1383 (
1384 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1385 &self.output,
1386 ),
1387 <OutputValidityProof as alloy_sol_types::SolType>::tokenize(
1388 &self.proof,
1389 ),
1390 )
1391 }
1392 #[inline]
1393 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1394 executeOutputReturn::_tokenize(ret)
1395 }
1396 #[inline]
1397 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1398 <Self::ReturnTuple<
1399 '_,
1400 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1401 .map(Into::into)
1402 }
1403 #[inline]
1404 fn abi_decode_returns_validate(
1405 data: &[u8],
1406 ) -> alloy_sol_types::Result<Self::Return> {
1407 <Self::ReturnTuple<
1408 '_,
1409 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1410 .map(Into::into)
1411 }
1412 }
1413 };
1414 #[derive(serde::Serialize, serde::Deserialize)]
1415 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1416 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1421 #[derive(Clone)]
1422 pub struct getDataAvailabilityCall;
1423 #[derive(serde::Serialize, serde::Deserialize)]
1424 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1425 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1427 #[derive(Clone)]
1428 pub struct getDataAvailabilityReturn {
1429 #[allow(missing_docs)]
1430 pub _0: alloy::sol_types::private::Bytes,
1431 }
1432 #[allow(
1433 non_camel_case_types,
1434 non_snake_case,
1435 clippy::pub_underscore_fields,
1436 clippy::style
1437 )]
1438 const _: () = {
1439 use alloy::sol_types as alloy_sol_types;
1440 {
1441 #[doc(hidden)]
1442 #[allow(dead_code)]
1443 type UnderlyingSolTuple<'a> = ();
1444 #[doc(hidden)]
1445 type UnderlyingRustTuple<'a> = ();
1446 #[cfg(test)]
1447 #[allow(dead_code, unreachable_patterns)]
1448 fn _type_assertion(
1449 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1450 ) {
1451 match _t {
1452 alloy_sol_types::private::AssertTypeEq::<
1453 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1454 >(_) => {}
1455 }
1456 }
1457 #[automatically_derived]
1458 #[doc(hidden)]
1459 impl ::core::convert::From<getDataAvailabilityCall>
1460 for UnderlyingRustTuple<'_> {
1461 fn from(value: getDataAvailabilityCall) -> Self {
1462 ()
1463 }
1464 }
1465 #[automatically_derived]
1466 #[doc(hidden)]
1467 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1468 for getDataAvailabilityCall {
1469 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1470 Self
1471 }
1472 }
1473 }
1474 {
1475 #[doc(hidden)]
1476 #[allow(dead_code)]
1477 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bytes,);
1478 #[doc(hidden)]
1479 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Bytes,);
1480 #[cfg(test)]
1481 #[allow(dead_code, unreachable_patterns)]
1482 fn _type_assertion(
1483 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1484 ) {
1485 match _t {
1486 alloy_sol_types::private::AssertTypeEq::<
1487 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1488 >(_) => {}
1489 }
1490 }
1491 #[automatically_derived]
1492 #[doc(hidden)]
1493 impl ::core::convert::From<getDataAvailabilityReturn>
1494 for UnderlyingRustTuple<'_> {
1495 fn from(value: getDataAvailabilityReturn) -> Self {
1496 (value._0,)
1497 }
1498 }
1499 #[automatically_derived]
1500 #[doc(hidden)]
1501 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1502 for getDataAvailabilityReturn {
1503 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1504 Self { _0: tuple.0 }
1505 }
1506 }
1507 }
1508 #[automatically_derived]
1509 impl alloy_sol_types::SolCall for getDataAvailabilityCall {
1510 type Parameters<'a> = ();
1511 type Token<'a> = <Self::Parameters<
1512 'a,
1513 > as alloy_sol_types::SolType>::Token<'a>;
1514 type Return = alloy::sol_types::private::Bytes;
1515 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bytes,);
1516 type ReturnToken<'a> = <Self::ReturnTuple<
1517 'a,
1518 > as alloy_sol_types::SolType>::Token<'a>;
1519 const SIGNATURE: &'static str = "getDataAvailability()";
1520 const SELECTOR: [u8; 4] = [240u8, 36u8, 120u8, 222u8];
1521 #[inline]
1522 fn new<'a>(
1523 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1524 ) -> Self {
1525 tuple.into()
1526 }
1527 #[inline]
1528 fn tokenize(&self) -> Self::Token<'_> {
1529 ()
1530 }
1531 #[inline]
1532 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1533 (
1534 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
1535 ret,
1536 ),
1537 )
1538 }
1539 #[inline]
1540 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1541 <Self::ReturnTuple<
1542 '_,
1543 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1544 .map(|r| {
1545 let r: getDataAvailabilityReturn = r.into();
1546 r._0
1547 })
1548 }
1549 #[inline]
1550 fn abi_decode_returns_validate(
1551 data: &[u8],
1552 ) -> alloy_sol_types::Result<Self::Return> {
1553 <Self::ReturnTuple<
1554 '_,
1555 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1556 .map(|r| {
1557 let r: getDataAvailabilityReturn = r.into();
1558 r._0
1559 })
1560 }
1561 }
1562 };
1563 #[derive(serde::Serialize, serde::Deserialize)]
1564 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1565 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1570 #[derive(Clone)]
1571 pub struct getDeploymentBlockNumberCall;
1572 #[derive(serde::Serialize, serde::Deserialize)]
1573 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1574 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1576 #[derive(Clone)]
1577 pub struct getDeploymentBlockNumberReturn {
1578 #[allow(missing_docs)]
1579 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1580 }
1581 #[allow(
1582 non_camel_case_types,
1583 non_snake_case,
1584 clippy::pub_underscore_fields,
1585 clippy::style
1586 )]
1587 const _: () = {
1588 use alloy::sol_types as alloy_sol_types;
1589 {
1590 #[doc(hidden)]
1591 #[allow(dead_code)]
1592 type UnderlyingSolTuple<'a> = ();
1593 #[doc(hidden)]
1594 type UnderlyingRustTuple<'a> = ();
1595 #[cfg(test)]
1596 #[allow(dead_code, unreachable_patterns)]
1597 fn _type_assertion(
1598 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1599 ) {
1600 match _t {
1601 alloy_sol_types::private::AssertTypeEq::<
1602 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1603 >(_) => {}
1604 }
1605 }
1606 #[automatically_derived]
1607 #[doc(hidden)]
1608 impl ::core::convert::From<getDeploymentBlockNumberCall>
1609 for UnderlyingRustTuple<'_> {
1610 fn from(value: getDeploymentBlockNumberCall) -> Self {
1611 ()
1612 }
1613 }
1614 #[automatically_derived]
1615 #[doc(hidden)]
1616 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1617 for getDeploymentBlockNumberCall {
1618 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1619 Self
1620 }
1621 }
1622 }
1623 {
1624 #[doc(hidden)]
1625 #[allow(dead_code)]
1626 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1627 #[doc(hidden)]
1628 type UnderlyingRustTuple<'a> = (
1629 alloy::sol_types::private::primitives::aliases::U256,
1630 );
1631 #[cfg(test)]
1632 #[allow(dead_code, unreachable_patterns)]
1633 fn _type_assertion(
1634 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1635 ) {
1636 match _t {
1637 alloy_sol_types::private::AssertTypeEq::<
1638 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1639 >(_) => {}
1640 }
1641 }
1642 #[automatically_derived]
1643 #[doc(hidden)]
1644 impl ::core::convert::From<getDeploymentBlockNumberReturn>
1645 for UnderlyingRustTuple<'_> {
1646 fn from(value: getDeploymentBlockNumberReturn) -> Self {
1647 (value._0,)
1648 }
1649 }
1650 #[automatically_derived]
1651 #[doc(hidden)]
1652 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1653 for getDeploymentBlockNumberReturn {
1654 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1655 Self { _0: tuple.0 }
1656 }
1657 }
1658 }
1659 #[automatically_derived]
1660 impl alloy_sol_types::SolCall for getDeploymentBlockNumberCall {
1661 type Parameters<'a> = ();
1662 type Token<'a> = <Self::Parameters<
1663 'a,
1664 > as alloy_sol_types::SolType>::Token<'a>;
1665 type Return = alloy::sol_types::private::primitives::aliases::U256;
1666 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1667 type ReturnToken<'a> = <Self::ReturnTuple<
1668 'a,
1669 > as alloy_sol_types::SolType>::Token<'a>;
1670 const SIGNATURE: &'static str = "getDeploymentBlockNumber()";
1671 const SELECTOR: [u8; 4] = [179u8, 161u8, 172u8, 216u8];
1672 #[inline]
1673 fn new<'a>(
1674 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1675 ) -> Self {
1676 tuple.into()
1677 }
1678 #[inline]
1679 fn tokenize(&self) -> Self::Token<'_> {
1680 ()
1681 }
1682 #[inline]
1683 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1684 (
1685 <alloy::sol_types::sol_data::Uint<
1686 256,
1687 > as alloy_sol_types::SolType>::tokenize(ret),
1688 )
1689 }
1690 #[inline]
1691 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1692 <Self::ReturnTuple<
1693 '_,
1694 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1695 .map(|r| {
1696 let r: getDeploymentBlockNumberReturn = r.into();
1697 r._0
1698 })
1699 }
1700 #[inline]
1701 fn abi_decode_returns_validate(
1702 data: &[u8],
1703 ) -> alloy_sol_types::Result<Self::Return> {
1704 <Self::ReturnTuple<
1705 '_,
1706 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1707 .map(|r| {
1708 let r: getDeploymentBlockNumberReturn = r.into();
1709 r._0
1710 })
1711 }
1712 }
1713 };
1714 #[derive(serde::Serialize, serde::Deserialize)]
1715 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1716 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1721 #[derive(Clone)]
1722 pub struct getNumberOfExecutedOutputsCall;
1723 #[derive(serde::Serialize, serde::Deserialize)]
1724 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1725 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1727 #[derive(Clone)]
1728 pub struct getNumberOfExecutedOutputsReturn {
1729 #[allow(missing_docs)]
1730 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1731 }
1732 #[allow(
1733 non_camel_case_types,
1734 non_snake_case,
1735 clippy::pub_underscore_fields,
1736 clippy::style
1737 )]
1738 const _: () = {
1739 use alloy::sol_types as alloy_sol_types;
1740 {
1741 #[doc(hidden)]
1742 #[allow(dead_code)]
1743 type UnderlyingSolTuple<'a> = ();
1744 #[doc(hidden)]
1745 type UnderlyingRustTuple<'a> = ();
1746 #[cfg(test)]
1747 #[allow(dead_code, unreachable_patterns)]
1748 fn _type_assertion(
1749 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1750 ) {
1751 match _t {
1752 alloy_sol_types::private::AssertTypeEq::<
1753 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1754 >(_) => {}
1755 }
1756 }
1757 #[automatically_derived]
1758 #[doc(hidden)]
1759 impl ::core::convert::From<getNumberOfExecutedOutputsCall>
1760 for UnderlyingRustTuple<'_> {
1761 fn from(value: getNumberOfExecutedOutputsCall) -> Self {
1762 ()
1763 }
1764 }
1765 #[automatically_derived]
1766 #[doc(hidden)]
1767 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1768 for getNumberOfExecutedOutputsCall {
1769 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1770 Self
1771 }
1772 }
1773 }
1774 {
1775 #[doc(hidden)]
1776 #[allow(dead_code)]
1777 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1778 #[doc(hidden)]
1779 type UnderlyingRustTuple<'a> = (
1780 alloy::sol_types::private::primitives::aliases::U256,
1781 );
1782 #[cfg(test)]
1783 #[allow(dead_code, unreachable_patterns)]
1784 fn _type_assertion(
1785 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1786 ) {
1787 match _t {
1788 alloy_sol_types::private::AssertTypeEq::<
1789 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1790 >(_) => {}
1791 }
1792 }
1793 #[automatically_derived]
1794 #[doc(hidden)]
1795 impl ::core::convert::From<getNumberOfExecutedOutputsReturn>
1796 for UnderlyingRustTuple<'_> {
1797 fn from(value: getNumberOfExecutedOutputsReturn) -> Self {
1798 (value._0,)
1799 }
1800 }
1801 #[automatically_derived]
1802 #[doc(hidden)]
1803 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1804 for getNumberOfExecutedOutputsReturn {
1805 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1806 Self { _0: tuple.0 }
1807 }
1808 }
1809 }
1810 #[automatically_derived]
1811 impl alloy_sol_types::SolCall for getNumberOfExecutedOutputsCall {
1812 type Parameters<'a> = ();
1813 type Token<'a> = <Self::Parameters<
1814 'a,
1815 > as alloy_sol_types::SolType>::Token<'a>;
1816 type Return = alloy::sol_types::private::primitives::aliases::U256;
1817 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1818 type ReturnToken<'a> = <Self::ReturnTuple<
1819 'a,
1820 > as alloy_sol_types::SolType>::Token<'a>;
1821 const SIGNATURE: &'static str = "getNumberOfExecutedOutputs()";
1822 const SELECTOR: [u8; 4] = [230u8, 79u8, 171u8, 77u8];
1823 #[inline]
1824 fn new<'a>(
1825 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1826 ) -> Self {
1827 tuple.into()
1828 }
1829 #[inline]
1830 fn tokenize(&self) -> Self::Token<'_> {
1831 ()
1832 }
1833 #[inline]
1834 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1835 (
1836 <alloy::sol_types::sol_data::Uint<
1837 256,
1838 > as alloy_sol_types::SolType>::tokenize(ret),
1839 )
1840 }
1841 #[inline]
1842 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1843 <Self::ReturnTuple<
1844 '_,
1845 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1846 .map(|r| {
1847 let r: getNumberOfExecutedOutputsReturn = r.into();
1848 r._0
1849 })
1850 }
1851 #[inline]
1852 fn abi_decode_returns_validate(
1853 data: &[u8],
1854 ) -> alloy_sol_types::Result<Self::Return> {
1855 <Self::ReturnTuple<
1856 '_,
1857 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1858 .map(|r| {
1859 let r: getNumberOfExecutedOutputsReturn = r.into();
1860 r._0
1861 })
1862 }
1863 }
1864 };
1865 #[derive(serde::Serialize, serde::Deserialize)]
1866 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1867 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1872 #[derive(Clone)]
1873 pub struct getOutputsMerkleRootValidatorCall;
1874 #[derive(serde::Serialize, serde::Deserialize)]
1875 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1876 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1878 #[derive(Clone)]
1879 pub struct getOutputsMerkleRootValidatorReturn {
1880 #[allow(missing_docs)]
1881 pub _0: alloy::sol_types::private::Address,
1882 }
1883 #[allow(
1884 non_camel_case_types,
1885 non_snake_case,
1886 clippy::pub_underscore_fields,
1887 clippy::style
1888 )]
1889 const _: () = {
1890 use alloy::sol_types as alloy_sol_types;
1891 {
1892 #[doc(hidden)]
1893 #[allow(dead_code)]
1894 type UnderlyingSolTuple<'a> = ();
1895 #[doc(hidden)]
1896 type UnderlyingRustTuple<'a> = ();
1897 #[cfg(test)]
1898 #[allow(dead_code, unreachable_patterns)]
1899 fn _type_assertion(
1900 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1901 ) {
1902 match _t {
1903 alloy_sol_types::private::AssertTypeEq::<
1904 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1905 >(_) => {}
1906 }
1907 }
1908 #[automatically_derived]
1909 #[doc(hidden)]
1910 impl ::core::convert::From<getOutputsMerkleRootValidatorCall>
1911 for UnderlyingRustTuple<'_> {
1912 fn from(value: getOutputsMerkleRootValidatorCall) -> Self {
1913 ()
1914 }
1915 }
1916 #[automatically_derived]
1917 #[doc(hidden)]
1918 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1919 for getOutputsMerkleRootValidatorCall {
1920 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1921 Self
1922 }
1923 }
1924 }
1925 {
1926 #[doc(hidden)]
1927 #[allow(dead_code)]
1928 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1929 #[doc(hidden)]
1930 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1931 #[cfg(test)]
1932 #[allow(dead_code, unreachable_patterns)]
1933 fn _type_assertion(
1934 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1935 ) {
1936 match _t {
1937 alloy_sol_types::private::AssertTypeEq::<
1938 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1939 >(_) => {}
1940 }
1941 }
1942 #[automatically_derived]
1943 #[doc(hidden)]
1944 impl ::core::convert::From<getOutputsMerkleRootValidatorReturn>
1945 for UnderlyingRustTuple<'_> {
1946 fn from(value: getOutputsMerkleRootValidatorReturn) -> Self {
1947 (value._0,)
1948 }
1949 }
1950 #[automatically_derived]
1951 #[doc(hidden)]
1952 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1953 for getOutputsMerkleRootValidatorReturn {
1954 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1955 Self { _0: tuple.0 }
1956 }
1957 }
1958 }
1959 #[automatically_derived]
1960 impl alloy_sol_types::SolCall for getOutputsMerkleRootValidatorCall {
1961 type Parameters<'a> = ();
1962 type Token<'a> = <Self::Parameters<
1963 'a,
1964 > as alloy_sol_types::SolType>::Token<'a>;
1965 type Return = alloy::sol_types::private::Address;
1966 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
1967 type ReturnToken<'a> = <Self::ReturnTuple<
1968 'a,
1969 > as alloy_sol_types::SolType>::Token<'a>;
1970 const SIGNATURE: &'static str = "getOutputsMerkleRootValidator()";
1971 const SELECTOR: [u8; 4] = [169u8, 77u8, 252u8, 90u8];
1972 #[inline]
1973 fn new<'a>(
1974 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1975 ) -> Self {
1976 tuple.into()
1977 }
1978 #[inline]
1979 fn tokenize(&self) -> Self::Token<'_> {
1980 ()
1981 }
1982 #[inline]
1983 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
1984 (
1985 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1986 ret,
1987 ),
1988 )
1989 }
1990 #[inline]
1991 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
1992 <Self::ReturnTuple<
1993 '_,
1994 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
1995 .map(|r| {
1996 let r: getOutputsMerkleRootValidatorReturn = r.into();
1997 r._0
1998 })
1999 }
2000 #[inline]
2001 fn abi_decode_returns_validate(
2002 data: &[u8],
2003 ) -> alloy_sol_types::Result<Self::Return> {
2004 <Self::ReturnTuple<
2005 '_,
2006 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2007 .map(|r| {
2008 let r: getOutputsMerkleRootValidatorReturn = r.into();
2009 r._0
2010 })
2011 }
2012 }
2013 };
2014 #[derive(serde::Serialize, serde::Deserialize)]
2015 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2016 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2021 #[derive(Clone)]
2022 pub struct getTemplateHashCall;
2023 #[derive(serde::Serialize, serde::Deserialize)]
2024 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2025 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2027 #[derive(Clone)]
2028 pub struct getTemplateHashReturn {
2029 #[allow(missing_docs)]
2030 pub _0: alloy::sol_types::private::FixedBytes<32>,
2031 }
2032 #[allow(
2033 non_camel_case_types,
2034 non_snake_case,
2035 clippy::pub_underscore_fields,
2036 clippy::style
2037 )]
2038 const _: () = {
2039 use alloy::sol_types as alloy_sol_types;
2040 {
2041 #[doc(hidden)]
2042 #[allow(dead_code)]
2043 type UnderlyingSolTuple<'a> = ();
2044 #[doc(hidden)]
2045 type UnderlyingRustTuple<'a> = ();
2046 #[cfg(test)]
2047 #[allow(dead_code, unreachable_patterns)]
2048 fn _type_assertion(
2049 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2050 ) {
2051 match _t {
2052 alloy_sol_types::private::AssertTypeEq::<
2053 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2054 >(_) => {}
2055 }
2056 }
2057 #[automatically_derived]
2058 #[doc(hidden)]
2059 impl ::core::convert::From<getTemplateHashCall> for UnderlyingRustTuple<'_> {
2060 fn from(value: getTemplateHashCall) -> Self {
2061 ()
2062 }
2063 }
2064 #[automatically_derived]
2065 #[doc(hidden)]
2066 impl ::core::convert::From<UnderlyingRustTuple<'_>> for getTemplateHashCall {
2067 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2068 Self
2069 }
2070 }
2071 }
2072 {
2073 #[doc(hidden)]
2074 #[allow(dead_code)]
2075 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2076 #[doc(hidden)]
2077 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<32>,);
2078 #[cfg(test)]
2079 #[allow(dead_code, unreachable_patterns)]
2080 fn _type_assertion(
2081 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2082 ) {
2083 match _t {
2084 alloy_sol_types::private::AssertTypeEq::<
2085 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2086 >(_) => {}
2087 }
2088 }
2089 #[automatically_derived]
2090 #[doc(hidden)]
2091 impl ::core::convert::From<getTemplateHashReturn>
2092 for UnderlyingRustTuple<'_> {
2093 fn from(value: getTemplateHashReturn) -> Self {
2094 (value._0,)
2095 }
2096 }
2097 #[automatically_derived]
2098 #[doc(hidden)]
2099 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2100 for getTemplateHashReturn {
2101 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2102 Self { _0: tuple.0 }
2103 }
2104 }
2105 }
2106 #[automatically_derived]
2107 impl alloy_sol_types::SolCall for getTemplateHashCall {
2108 type Parameters<'a> = ();
2109 type Token<'a> = <Self::Parameters<
2110 'a,
2111 > as alloy_sol_types::SolType>::Token<'a>;
2112 type Return = alloy::sol_types::private::FixedBytes<32>;
2113 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<32>,);
2114 type ReturnToken<'a> = <Self::ReturnTuple<
2115 'a,
2116 > as alloy_sol_types::SolType>::Token<'a>;
2117 const SIGNATURE: &'static str = "getTemplateHash()";
2118 const SELECTOR: [u8; 4] = [97u8, 177u8, 44u8, 102u8];
2119 #[inline]
2120 fn new<'a>(
2121 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2122 ) -> Self {
2123 tuple.into()
2124 }
2125 #[inline]
2126 fn tokenize(&self) -> Self::Token<'_> {
2127 ()
2128 }
2129 #[inline]
2130 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2131 (
2132 <alloy::sol_types::sol_data::FixedBytes<
2133 32,
2134 > as alloy_sol_types::SolType>::tokenize(ret),
2135 )
2136 }
2137 #[inline]
2138 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2139 <Self::ReturnTuple<
2140 '_,
2141 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2142 .map(|r| {
2143 let r: getTemplateHashReturn = r.into();
2144 r._0
2145 })
2146 }
2147 #[inline]
2148 fn abi_decode_returns_validate(
2149 data: &[u8],
2150 ) -> alloy_sol_types::Result<Self::Return> {
2151 <Self::ReturnTuple<
2152 '_,
2153 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2154 .map(|r| {
2155 let r: getTemplateHashReturn = r.into();
2156 r._0
2157 })
2158 }
2159 }
2160 };
2161 #[derive(serde::Serialize, serde::Deserialize)]
2162 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2163 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2168 #[derive(Clone)]
2169 pub struct migrateToOutputsMerkleRootValidatorCall {
2170 #[allow(missing_docs)]
2171 pub newOutputsMerkleRootValidator: alloy::sol_types::private::Address,
2172 }
2173 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2175 #[derive(Clone)]
2176 pub struct migrateToOutputsMerkleRootValidatorReturn {}
2177 #[allow(
2178 non_camel_case_types,
2179 non_snake_case,
2180 clippy::pub_underscore_fields,
2181 clippy::style
2182 )]
2183 const _: () = {
2184 use alloy::sol_types as alloy_sol_types;
2185 {
2186 #[doc(hidden)]
2187 #[allow(dead_code)]
2188 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2189 #[doc(hidden)]
2190 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2191 #[cfg(test)]
2192 #[allow(dead_code, unreachable_patterns)]
2193 fn _type_assertion(
2194 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2195 ) {
2196 match _t {
2197 alloy_sol_types::private::AssertTypeEq::<
2198 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2199 >(_) => {}
2200 }
2201 }
2202 #[automatically_derived]
2203 #[doc(hidden)]
2204 impl ::core::convert::From<migrateToOutputsMerkleRootValidatorCall>
2205 for UnderlyingRustTuple<'_> {
2206 fn from(value: migrateToOutputsMerkleRootValidatorCall) -> Self {
2207 (value.newOutputsMerkleRootValidator,)
2208 }
2209 }
2210 #[automatically_derived]
2211 #[doc(hidden)]
2212 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2213 for migrateToOutputsMerkleRootValidatorCall {
2214 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2215 Self {
2216 newOutputsMerkleRootValidator: tuple.0,
2217 }
2218 }
2219 }
2220 }
2221 {
2222 #[doc(hidden)]
2223 #[allow(dead_code)]
2224 type UnderlyingSolTuple<'a> = ();
2225 #[doc(hidden)]
2226 type UnderlyingRustTuple<'a> = ();
2227 #[cfg(test)]
2228 #[allow(dead_code, unreachable_patterns)]
2229 fn _type_assertion(
2230 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2231 ) {
2232 match _t {
2233 alloy_sol_types::private::AssertTypeEq::<
2234 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2235 >(_) => {}
2236 }
2237 }
2238 #[automatically_derived]
2239 #[doc(hidden)]
2240 impl ::core::convert::From<migrateToOutputsMerkleRootValidatorReturn>
2241 for UnderlyingRustTuple<'_> {
2242 fn from(value: migrateToOutputsMerkleRootValidatorReturn) -> Self {
2243 ()
2244 }
2245 }
2246 #[automatically_derived]
2247 #[doc(hidden)]
2248 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2249 for migrateToOutputsMerkleRootValidatorReturn {
2250 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2251 Self {}
2252 }
2253 }
2254 }
2255 impl migrateToOutputsMerkleRootValidatorReturn {
2256 fn _tokenize(
2257 &self,
2258 ) -> <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::ReturnToken<
2259 '_,
2260 > {
2261 ()
2262 }
2263 }
2264 #[automatically_derived]
2265 impl alloy_sol_types::SolCall for migrateToOutputsMerkleRootValidatorCall {
2266 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2267 type Token<'a> = <Self::Parameters<
2268 'a,
2269 > as alloy_sol_types::SolType>::Token<'a>;
2270 type Return = migrateToOutputsMerkleRootValidatorReturn;
2271 type ReturnTuple<'a> = ();
2272 type ReturnToken<'a> = <Self::ReturnTuple<
2273 'a,
2274 > as alloy_sol_types::SolType>::Token<'a>;
2275 const SIGNATURE: &'static str = "migrateToOutputsMerkleRootValidator(address)";
2276 const SELECTOR: [u8; 4] = [191u8, 138u8, 191u8, 248u8];
2277 #[inline]
2278 fn new<'a>(
2279 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2280 ) -> Self {
2281 tuple.into()
2282 }
2283 #[inline]
2284 fn tokenize(&self) -> Self::Token<'_> {
2285 (
2286 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2287 &self.newOutputsMerkleRootValidator,
2288 ),
2289 )
2290 }
2291 #[inline]
2292 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2293 migrateToOutputsMerkleRootValidatorReturn::_tokenize(ret)
2294 }
2295 #[inline]
2296 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2297 <Self::ReturnTuple<
2298 '_,
2299 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2300 .map(Into::into)
2301 }
2302 #[inline]
2303 fn abi_decode_returns_validate(
2304 data: &[u8],
2305 ) -> alloy_sol_types::Result<Self::Return> {
2306 <Self::ReturnTuple<
2307 '_,
2308 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2309 .map(Into::into)
2310 }
2311 }
2312 };
2313 #[derive(serde::Serialize, serde::Deserialize)]
2314 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2315 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2320 #[derive(Clone)]
2321 pub struct ownerCall;
2322 #[derive(serde::Serialize, serde::Deserialize)]
2323 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2324 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2326 #[derive(Clone)]
2327 pub struct ownerReturn {
2328 #[allow(missing_docs)]
2329 pub _0: alloy::sol_types::private::Address,
2330 }
2331 #[allow(
2332 non_camel_case_types,
2333 non_snake_case,
2334 clippy::pub_underscore_fields,
2335 clippy::style
2336 )]
2337 const _: () = {
2338 use alloy::sol_types as alloy_sol_types;
2339 {
2340 #[doc(hidden)]
2341 #[allow(dead_code)]
2342 type UnderlyingSolTuple<'a> = ();
2343 #[doc(hidden)]
2344 type UnderlyingRustTuple<'a> = ();
2345 #[cfg(test)]
2346 #[allow(dead_code, unreachable_patterns)]
2347 fn _type_assertion(
2348 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2349 ) {
2350 match _t {
2351 alloy_sol_types::private::AssertTypeEq::<
2352 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2353 >(_) => {}
2354 }
2355 }
2356 #[automatically_derived]
2357 #[doc(hidden)]
2358 impl ::core::convert::From<ownerCall> for UnderlyingRustTuple<'_> {
2359 fn from(value: ownerCall) -> Self {
2360 ()
2361 }
2362 }
2363 #[automatically_derived]
2364 #[doc(hidden)]
2365 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerCall {
2366 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2367 Self
2368 }
2369 }
2370 }
2371 {
2372 #[doc(hidden)]
2373 #[allow(dead_code)]
2374 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2375 #[doc(hidden)]
2376 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2377 #[cfg(test)]
2378 #[allow(dead_code, unreachable_patterns)]
2379 fn _type_assertion(
2380 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2381 ) {
2382 match _t {
2383 alloy_sol_types::private::AssertTypeEq::<
2384 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2385 >(_) => {}
2386 }
2387 }
2388 #[automatically_derived]
2389 #[doc(hidden)]
2390 impl ::core::convert::From<ownerReturn> for UnderlyingRustTuple<'_> {
2391 fn from(value: ownerReturn) -> Self {
2392 (value._0,)
2393 }
2394 }
2395 #[automatically_derived]
2396 #[doc(hidden)]
2397 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ownerReturn {
2398 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2399 Self { _0: tuple.0 }
2400 }
2401 }
2402 }
2403 #[automatically_derived]
2404 impl alloy_sol_types::SolCall for ownerCall {
2405 type Parameters<'a> = ();
2406 type Token<'a> = <Self::Parameters<
2407 'a,
2408 > as alloy_sol_types::SolType>::Token<'a>;
2409 type Return = alloy::sol_types::private::Address;
2410 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
2411 type ReturnToken<'a> = <Self::ReturnTuple<
2412 'a,
2413 > as alloy_sol_types::SolType>::Token<'a>;
2414 const SIGNATURE: &'static str = "owner()";
2415 const SELECTOR: [u8; 4] = [141u8, 165u8, 203u8, 91u8];
2416 #[inline]
2417 fn new<'a>(
2418 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2419 ) -> Self {
2420 tuple.into()
2421 }
2422 #[inline]
2423 fn tokenize(&self) -> Self::Token<'_> {
2424 ()
2425 }
2426 #[inline]
2427 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2428 (
2429 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2430 ret,
2431 ),
2432 )
2433 }
2434 #[inline]
2435 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2436 <Self::ReturnTuple<
2437 '_,
2438 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2439 .map(|r| {
2440 let r: ownerReturn = r.into();
2441 r._0
2442 })
2443 }
2444 #[inline]
2445 fn abi_decode_returns_validate(
2446 data: &[u8],
2447 ) -> alloy_sol_types::Result<Self::Return> {
2448 <Self::ReturnTuple<
2449 '_,
2450 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2451 .map(|r| {
2452 let r: ownerReturn = r.into();
2453 r._0
2454 })
2455 }
2456 }
2457 };
2458 #[derive(serde::Serialize, serde::Deserialize)]
2459 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2460 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2465 #[derive(Clone)]
2466 pub struct renounceOwnershipCall;
2467 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2469 #[derive(Clone)]
2470 pub struct renounceOwnershipReturn {}
2471 #[allow(
2472 non_camel_case_types,
2473 non_snake_case,
2474 clippy::pub_underscore_fields,
2475 clippy::style
2476 )]
2477 const _: () = {
2478 use alloy::sol_types as alloy_sol_types;
2479 {
2480 #[doc(hidden)]
2481 #[allow(dead_code)]
2482 type UnderlyingSolTuple<'a> = ();
2483 #[doc(hidden)]
2484 type UnderlyingRustTuple<'a> = ();
2485 #[cfg(test)]
2486 #[allow(dead_code, unreachable_patterns)]
2487 fn _type_assertion(
2488 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2489 ) {
2490 match _t {
2491 alloy_sol_types::private::AssertTypeEq::<
2492 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2493 >(_) => {}
2494 }
2495 }
2496 #[automatically_derived]
2497 #[doc(hidden)]
2498 impl ::core::convert::From<renounceOwnershipCall>
2499 for UnderlyingRustTuple<'_> {
2500 fn from(value: renounceOwnershipCall) -> Self {
2501 ()
2502 }
2503 }
2504 #[automatically_derived]
2505 #[doc(hidden)]
2506 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2507 for renounceOwnershipCall {
2508 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2509 Self
2510 }
2511 }
2512 }
2513 {
2514 #[doc(hidden)]
2515 #[allow(dead_code)]
2516 type UnderlyingSolTuple<'a> = ();
2517 #[doc(hidden)]
2518 type UnderlyingRustTuple<'a> = ();
2519 #[cfg(test)]
2520 #[allow(dead_code, unreachable_patterns)]
2521 fn _type_assertion(
2522 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2523 ) {
2524 match _t {
2525 alloy_sol_types::private::AssertTypeEq::<
2526 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2527 >(_) => {}
2528 }
2529 }
2530 #[automatically_derived]
2531 #[doc(hidden)]
2532 impl ::core::convert::From<renounceOwnershipReturn>
2533 for UnderlyingRustTuple<'_> {
2534 fn from(value: renounceOwnershipReturn) -> Self {
2535 ()
2536 }
2537 }
2538 #[automatically_derived]
2539 #[doc(hidden)]
2540 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2541 for renounceOwnershipReturn {
2542 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2543 Self {}
2544 }
2545 }
2546 }
2547 impl renounceOwnershipReturn {
2548 fn _tokenize(
2549 &self,
2550 ) -> <renounceOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2551 ()
2552 }
2553 }
2554 #[automatically_derived]
2555 impl alloy_sol_types::SolCall for renounceOwnershipCall {
2556 type Parameters<'a> = ();
2557 type Token<'a> = <Self::Parameters<
2558 'a,
2559 > as alloy_sol_types::SolType>::Token<'a>;
2560 type Return = renounceOwnershipReturn;
2561 type ReturnTuple<'a> = ();
2562 type ReturnToken<'a> = <Self::ReturnTuple<
2563 'a,
2564 > as alloy_sol_types::SolType>::Token<'a>;
2565 const SIGNATURE: &'static str = "renounceOwnership()";
2566 const SELECTOR: [u8; 4] = [113u8, 80u8, 24u8, 166u8];
2567 #[inline]
2568 fn new<'a>(
2569 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2570 ) -> Self {
2571 tuple.into()
2572 }
2573 #[inline]
2574 fn tokenize(&self) -> Self::Token<'_> {
2575 ()
2576 }
2577 #[inline]
2578 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2579 renounceOwnershipReturn::_tokenize(ret)
2580 }
2581 #[inline]
2582 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2583 <Self::ReturnTuple<
2584 '_,
2585 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2586 .map(Into::into)
2587 }
2588 #[inline]
2589 fn abi_decode_returns_validate(
2590 data: &[u8],
2591 ) -> alloy_sol_types::Result<Self::Return> {
2592 <Self::ReturnTuple<
2593 '_,
2594 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2595 .map(Into::into)
2596 }
2597 }
2598 };
2599 #[derive(serde::Serialize, serde::Deserialize)]
2600 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2601 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2606 #[derive(Clone)]
2607 pub struct transferOwnershipCall {
2608 #[allow(missing_docs)]
2609 pub newOwner: alloy::sol_types::private::Address,
2610 }
2611 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2613 #[derive(Clone)]
2614 pub struct transferOwnershipReturn {}
2615 #[allow(
2616 non_camel_case_types,
2617 non_snake_case,
2618 clippy::pub_underscore_fields,
2619 clippy::style
2620 )]
2621 const _: () = {
2622 use alloy::sol_types as alloy_sol_types;
2623 {
2624 #[doc(hidden)]
2625 #[allow(dead_code)]
2626 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2627 #[doc(hidden)]
2628 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2629 #[cfg(test)]
2630 #[allow(dead_code, unreachable_patterns)]
2631 fn _type_assertion(
2632 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2633 ) {
2634 match _t {
2635 alloy_sol_types::private::AssertTypeEq::<
2636 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2637 >(_) => {}
2638 }
2639 }
2640 #[automatically_derived]
2641 #[doc(hidden)]
2642 impl ::core::convert::From<transferOwnershipCall>
2643 for UnderlyingRustTuple<'_> {
2644 fn from(value: transferOwnershipCall) -> Self {
2645 (value.newOwner,)
2646 }
2647 }
2648 #[automatically_derived]
2649 #[doc(hidden)]
2650 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2651 for transferOwnershipCall {
2652 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2653 Self { newOwner: tuple.0 }
2654 }
2655 }
2656 }
2657 {
2658 #[doc(hidden)]
2659 #[allow(dead_code)]
2660 type UnderlyingSolTuple<'a> = ();
2661 #[doc(hidden)]
2662 type UnderlyingRustTuple<'a> = ();
2663 #[cfg(test)]
2664 #[allow(dead_code, unreachable_patterns)]
2665 fn _type_assertion(
2666 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2667 ) {
2668 match _t {
2669 alloy_sol_types::private::AssertTypeEq::<
2670 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2671 >(_) => {}
2672 }
2673 }
2674 #[automatically_derived]
2675 #[doc(hidden)]
2676 impl ::core::convert::From<transferOwnershipReturn>
2677 for UnderlyingRustTuple<'_> {
2678 fn from(value: transferOwnershipReturn) -> Self {
2679 ()
2680 }
2681 }
2682 #[automatically_derived]
2683 #[doc(hidden)]
2684 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2685 for transferOwnershipReturn {
2686 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2687 Self {}
2688 }
2689 }
2690 }
2691 impl transferOwnershipReturn {
2692 fn _tokenize(
2693 &self,
2694 ) -> <transferOwnershipCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2695 ()
2696 }
2697 }
2698 #[automatically_derived]
2699 impl alloy_sol_types::SolCall for transferOwnershipCall {
2700 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2701 type Token<'a> = <Self::Parameters<
2702 'a,
2703 > as alloy_sol_types::SolType>::Token<'a>;
2704 type Return = transferOwnershipReturn;
2705 type ReturnTuple<'a> = ();
2706 type ReturnToken<'a> = <Self::ReturnTuple<
2707 'a,
2708 > as alloy_sol_types::SolType>::Token<'a>;
2709 const SIGNATURE: &'static str = "transferOwnership(address)";
2710 const SELECTOR: [u8; 4] = [242u8, 253u8, 227u8, 139u8];
2711 #[inline]
2712 fn new<'a>(
2713 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2714 ) -> Self {
2715 tuple.into()
2716 }
2717 #[inline]
2718 fn tokenize(&self) -> Self::Token<'_> {
2719 (
2720 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2721 &self.newOwner,
2722 ),
2723 )
2724 }
2725 #[inline]
2726 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2727 transferOwnershipReturn::_tokenize(ret)
2728 }
2729 #[inline]
2730 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2731 <Self::ReturnTuple<
2732 '_,
2733 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2734 .map(Into::into)
2735 }
2736 #[inline]
2737 fn abi_decode_returns_validate(
2738 data: &[u8],
2739 ) -> alloy_sol_types::Result<Self::Return> {
2740 <Self::ReturnTuple<
2741 '_,
2742 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2743 .map(Into::into)
2744 }
2745 }
2746 };
2747 #[derive(serde::Serialize, serde::Deserialize)]
2748 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2749 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2754 #[derive(Clone)]
2755 pub struct validateOutputCall {
2756 #[allow(missing_docs)]
2757 pub output: alloy::sol_types::private::Bytes,
2758 #[allow(missing_docs)]
2759 pub proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
2760 }
2761 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2763 #[derive(Clone)]
2764 pub struct validateOutputReturn {}
2765 #[allow(
2766 non_camel_case_types,
2767 non_snake_case,
2768 clippy::pub_underscore_fields,
2769 clippy::style
2770 )]
2771 const _: () = {
2772 use alloy::sol_types as alloy_sol_types;
2773 {
2774 #[doc(hidden)]
2775 #[allow(dead_code)]
2776 type UnderlyingSolTuple<'a> = (
2777 alloy::sol_types::sol_data::Bytes,
2778 OutputValidityProof,
2779 );
2780 #[doc(hidden)]
2781 type UnderlyingRustTuple<'a> = (
2782 alloy::sol_types::private::Bytes,
2783 <OutputValidityProof as alloy::sol_types::SolType>::RustType,
2784 );
2785 #[cfg(test)]
2786 #[allow(dead_code, unreachable_patterns)]
2787 fn _type_assertion(
2788 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2789 ) {
2790 match _t {
2791 alloy_sol_types::private::AssertTypeEq::<
2792 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2793 >(_) => {}
2794 }
2795 }
2796 #[automatically_derived]
2797 #[doc(hidden)]
2798 impl ::core::convert::From<validateOutputCall> for UnderlyingRustTuple<'_> {
2799 fn from(value: validateOutputCall) -> Self {
2800 (value.output, value.proof)
2801 }
2802 }
2803 #[automatically_derived]
2804 #[doc(hidden)]
2805 impl ::core::convert::From<UnderlyingRustTuple<'_>> for validateOutputCall {
2806 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2807 Self {
2808 output: tuple.0,
2809 proof: tuple.1,
2810 }
2811 }
2812 }
2813 }
2814 {
2815 #[doc(hidden)]
2816 #[allow(dead_code)]
2817 type UnderlyingSolTuple<'a> = ();
2818 #[doc(hidden)]
2819 type UnderlyingRustTuple<'a> = ();
2820 #[cfg(test)]
2821 #[allow(dead_code, unreachable_patterns)]
2822 fn _type_assertion(
2823 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2824 ) {
2825 match _t {
2826 alloy_sol_types::private::AssertTypeEq::<
2827 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2828 >(_) => {}
2829 }
2830 }
2831 #[automatically_derived]
2832 #[doc(hidden)]
2833 impl ::core::convert::From<validateOutputReturn>
2834 for UnderlyingRustTuple<'_> {
2835 fn from(value: validateOutputReturn) -> Self {
2836 ()
2837 }
2838 }
2839 #[automatically_derived]
2840 #[doc(hidden)]
2841 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2842 for validateOutputReturn {
2843 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2844 Self {}
2845 }
2846 }
2847 }
2848 impl validateOutputReturn {
2849 fn _tokenize(
2850 &self,
2851 ) -> <validateOutputCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
2852 ()
2853 }
2854 }
2855 #[automatically_derived]
2856 impl alloy_sol_types::SolCall for validateOutputCall {
2857 type Parameters<'a> = (
2858 alloy::sol_types::sol_data::Bytes,
2859 OutputValidityProof,
2860 );
2861 type Token<'a> = <Self::Parameters<
2862 'a,
2863 > as alloy_sol_types::SolType>::Token<'a>;
2864 type Return = validateOutputReturn;
2865 type ReturnTuple<'a> = ();
2866 type ReturnToken<'a> = <Self::ReturnTuple<
2867 'a,
2868 > as alloy_sol_types::SolType>::Token<'a>;
2869 const SIGNATURE: &'static str = "validateOutput(bytes,(uint64,bytes32[]))";
2870 const SELECTOR: [u8; 4] = [232u8, 141u8, 57u8, 192u8];
2871 #[inline]
2872 fn new<'a>(
2873 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2874 ) -> Self {
2875 tuple.into()
2876 }
2877 #[inline]
2878 fn tokenize(&self) -> Self::Token<'_> {
2879 (
2880 <alloy::sol_types::sol_data::Bytes as alloy_sol_types::SolType>::tokenize(
2881 &self.output,
2882 ),
2883 <OutputValidityProof as alloy_sol_types::SolType>::tokenize(
2884 &self.proof,
2885 ),
2886 )
2887 }
2888 #[inline]
2889 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2890 validateOutputReturn::_tokenize(ret)
2891 }
2892 #[inline]
2893 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2894 <Self::ReturnTuple<
2895 '_,
2896 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2897 .map(Into::into)
2898 }
2899 #[inline]
2900 fn abi_decode_returns_validate(
2901 data: &[u8],
2902 ) -> alloy_sol_types::Result<Self::Return> {
2903 <Self::ReturnTuple<
2904 '_,
2905 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2906 .map(Into::into)
2907 }
2908 }
2909 };
2910 #[derive(serde::Serialize, serde::Deserialize)]
2911 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2912 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2917 #[derive(Clone)]
2918 pub struct validateOutputHashCall {
2919 #[allow(missing_docs)]
2920 pub outputHash: alloy::sol_types::private::FixedBytes<32>,
2921 #[allow(missing_docs)]
2922 pub proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
2923 }
2924 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2926 #[derive(Clone)]
2927 pub struct validateOutputHashReturn {}
2928 #[allow(
2929 non_camel_case_types,
2930 non_snake_case,
2931 clippy::pub_underscore_fields,
2932 clippy::style
2933 )]
2934 const _: () = {
2935 use alloy::sol_types as alloy_sol_types;
2936 {
2937 #[doc(hidden)]
2938 #[allow(dead_code)]
2939 type UnderlyingSolTuple<'a> = (
2940 alloy::sol_types::sol_data::FixedBytes<32>,
2941 OutputValidityProof,
2942 );
2943 #[doc(hidden)]
2944 type UnderlyingRustTuple<'a> = (
2945 alloy::sol_types::private::FixedBytes<32>,
2946 <OutputValidityProof as alloy::sol_types::SolType>::RustType,
2947 );
2948 #[cfg(test)]
2949 #[allow(dead_code, unreachable_patterns)]
2950 fn _type_assertion(
2951 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2952 ) {
2953 match _t {
2954 alloy_sol_types::private::AssertTypeEq::<
2955 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2956 >(_) => {}
2957 }
2958 }
2959 #[automatically_derived]
2960 #[doc(hidden)]
2961 impl ::core::convert::From<validateOutputHashCall>
2962 for UnderlyingRustTuple<'_> {
2963 fn from(value: validateOutputHashCall) -> Self {
2964 (value.outputHash, value.proof)
2965 }
2966 }
2967 #[automatically_derived]
2968 #[doc(hidden)]
2969 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2970 for validateOutputHashCall {
2971 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2972 Self {
2973 outputHash: tuple.0,
2974 proof: tuple.1,
2975 }
2976 }
2977 }
2978 }
2979 {
2980 #[doc(hidden)]
2981 #[allow(dead_code)]
2982 type UnderlyingSolTuple<'a> = ();
2983 #[doc(hidden)]
2984 type UnderlyingRustTuple<'a> = ();
2985 #[cfg(test)]
2986 #[allow(dead_code, unreachable_patterns)]
2987 fn _type_assertion(
2988 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2989 ) {
2990 match _t {
2991 alloy_sol_types::private::AssertTypeEq::<
2992 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2993 >(_) => {}
2994 }
2995 }
2996 #[automatically_derived]
2997 #[doc(hidden)]
2998 impl ::core::convert::From<validateOutputHashReturn>
2999 for UnderlyingRustTuple<'_> {
3000 fn from(value: validateOutputHashReturn) -> Self {
3001 ()
3002 }
3003 }
3004 #[automatically_derived]
3005 #[doc(hidden)]
3006 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3007 for validateOutputHashReturn {
3008 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3009 Self {}
3010 }
3011 }
3012 }
3013 impl validateOutputHashReturn {
3014 fn _tokenize(
3015 &self,
3016 ) -> <validateOutputHashCall as alloy_sol_types::SolCall>::ReturnToken<'_> {
3017 ()
3018 }
3019 }
3020 #[automatically_derived]
3021 impl alloy_sol_types::SolCall for validateOutputHashCall {
3022 type Parameters<'a> = (
3023 alloy::sol_types::sol_data::FixedBytes<32>,
3024 OutputValidityProof,
3025 );
3026 type Token<'a> = <Self::Parameters<
3027 'a,
3028 > as alloy_sol_types::SolType>::Token<'a>;
3029 type Return = validateOutputHashReturn;
3030 type ReturnTuple<'a> = ();
3031 type ReturnToken<'a> = <Self::ReturnTuple<
3032 'a,
3033 > as alloy_sol_types::SolType>::Token<'a>;
3034 const SIGNATURE: &'static str = "validateOutputHash(bytes32,(uint64,bytes32[]))";
3035 const SELECTOR: [u8; 4] = [8u8, 235u8, 137u8, 171u8];
3036 #[inline]
3037 fn new<'a>(
3038 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3039 ) -> Self {
3040 tuple.into()
3041 }
3042 #[inline]
3043 fn tokenize(&self) -> Self::Token<'_> {
3044 (
3045 <alloy::sol_types::sol_data::FixedBytes<
3046 32,
3047 > as alloy_sol_types::SolType>::tokenize(&self.outputHash),
3048 <OutputValidityProof as alloy_sol_types::SolType>::tokenize(
3049 &self.proof,
3050 ),
3051 )
3052 }
3053 #[inline]
3054 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3055 validateOutputHashReturn::_tokenize(ret)
3056 }
3057 #[inline]
3058 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3059 <Self::ReturnTuple<
3060 '_,
3061 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3062 .map(Into::into)
3063 }
3064 #[inline]
3065 fn abi_decode_returns_validate(
3066 data: &[u8],
3067 ) -> alloy_sol_types::Result<Self::Return> {
3068 <Self::ReturnTuple<
3069 '_,
3070 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3071 .map(Into::into)
3072 }
3073 }
3074 };
3075 #[derive(serde::Serialize, serde::Deserialize)]
3076 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3077 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3082 #[derive(Clone)]
3083 pub struct wasOutputExecutedCall {
3084 #[allow(missing_docs)]
3085 pub outputIndex: alloy::sol_types::private::primitives::aliases::U256,
3086 }
3087 #[derive(serde::Serialize, serde::Deserialize)]
3088 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3089 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3091 #[derive(Clone)]
3092 pub struct wasOutputExecutedReturn {
3093 #[allow(missing_docs)]
3094 pub _0: bool,
3095 }
3096 #[allow(
3097 non_camel_case_types,
3098 non_snake_case,
3099 clippy::pub_underscore_fields,
3100 clippy::style
3101 )]
3102 const _: () = {
3103 use alloy::sol_types as alloy_sol_types;
3104 {
3105 #[doc(hidden)]
3106 #[allow(dead_code)]
3107 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3108 #[doc(hidden)]
3109 type UnderlyingRustTuple<'a> = (
3110 alloy::sol_types::private::primitives::aliases::U256,
3111 );
3112 #[cfg(test)]
3113 #[allow(dead_code, unreachable_patterns)]
3114 fn _type_assertion(
3115 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3116 ) {
3117 match _t {
3118 alloy_sol_types::private::AssertTypeEq::<
3119 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3120 >(_) => {}
3121 }
3122 }
3123 #[automatically_derived]
3124 #[doc(hidden)]
3125 impl ::core::convert::From<wasOutputExecutedCall>
3126 for UnderlyingRustTuple<'_> {
3127 fn from(value: wasOutputExecutedCall) -> Self {
3128 (value.outputIndex,)
3129 }
3130 }
3131 #[automatically_derived]
3132 #[doc(hidden)]
3133 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3134 for wasOutputExecutedCall {
3135 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3136 Self { outputIndex: tuple.0 }
3137 }
3138 }
3139 }
3140 {
3141 #[doc(hidden)]
3142 #[allow(dead_code)]
3143 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3144 #[doc(hidden)]
3145 type UnderlyingRustTuple<'a> = (bool,);
3146 #[cfg(test)]
3147 #[allow(dead_code, unreachable_patterns)]
3148 fn _type_assertion(
3149 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3150 ) {
3151 match _t {
3152 alloy_sol_types::private::AssertTypeEq::<
3153 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3154 >(_) => {}
3155 }
3156 }
3157 #[automatically_derived]
3158 #[doc(hidden)]
3159 impl ::core::convert::From<wasOutputExecutedReturn>
3160 for UnderlyingRustTuple<'_> {
3161 fn from(value: wasOutputExecutedReturn) -> Self {
3162 (value._0,)
3163 }
3164 }
3165 #[automatically_derived]
3166 #[doc(hidden)]
3167 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3168 for wasOutputExecutedReturn {
3169 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3170 Self { _0: tuple.0 }
3171 }
3172 }
3173 }
3174 #[automatically_derived]
3175 impl alloy_sol_types::SolCall for wasOutputExecutedCall {
3176 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
3177 type Token<'a> = <Self::Parameters<
3178 'a,
3179 > as alloy_sol_types::SolType>::Token<'a>;
3180 type Return = bool;
3181 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Bool,);
3182 type ReturnToken<'a> = <Self::ReturnTuple<
3183 'a,
3184 > as alloy_sol_types::SolType>::Token<'a>;
3185 const SIGNATURE: &'static str = "wasOutputExecuted(uint256)";
3186 const SELECTOR: [u8; 4] = [113u8, 137u8, 29u8, 176u8];
3187 #[inline]
3188 fn new<'a>(
3189 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3190 ) -> Self {
3191 tuple.into()
3192 }
3193 #[inline]
3194 fn tokenize(&self) -> Self::Token<'_> {
3195 (
3196 <alloy::sol_types::sol_data::Uint<
3197 256,
3198 > as alloy_sol_types::SolType>::tokenize(&self.outputIndex),
3199 )
3200 }
3201 #[inline]
3202 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3203 (
3204 <alloy::sol_types::sol_data::Bool as alloy_sol_types::SolType>::tokenize(
3205 ret,
3206 ),
3207 )
3208 }
3209 #[inline]
3210 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3211 <Self::ReturnTuple<
3212 '_,
3213 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3214 .map(|r| {
3215 let r: wasOutputExecutedReturn = r.into();
3216 r._0
3217 })
3218 }
3219 #[inline]
3220 fn abi_decode_returns_validate(
3221 data: &[u8],
3222 ) -> alloy_sol_types::Result<Self::Return> {
3223 <Self::ReturnTuple<
3224 '_,
3225 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3226 .map(|r| {
3227 let r: wasOutputExecutedReturn = r.into();
3228 r._0
3229 })
3230 }
3231 }
3232 };
3233 #[derive(Clone)]
3235 #[derive(serde::Serialize, serde::Deserialize)]
3236 #[derive()]
3237 pub enum IApplicationCalls {
3238 #[allow(missing_docs)]
3239 executeOutput(executeOutputCall),
3240 #[allow(missing_docs)]
3241 getDataAvailability(getDataAvailabilityCall),
3242 #[allow(missing_docs)]
3243 getDeploymentBlockNumber(getDeploymentBlockNumberCall),
3244 #[allow(missing_docs)]
3245 getNumberOfExecutedOutputs(getNumberOfExecutedOutputsCall),
3246 #[allow(missing_docs)]
3247 getOutputsMerkleRootValidator(getOutputsMerkleRootValidatorCall),
3248 #[allow(missing_docs)]
3249 getTemplateHash(getTemplateHashCall),
3250 #[allow(missing_docs)]
3251 migrateToOutputsMerkleRootValidator(migrateToOutputsMerkleRootValidatorCall),
3252 #[allow(missing_docs)]
3253 owner(ownerCall),
3254 #[allow(missing_docs)]
3255 renounceOwnership(renounceOwnershipCall),
3256 #[allow(missing_docs)]
3257 transferOwnership(transferOwnershipCall),
3258 #[allow(missing_docs)]
3259 validateOutput(validateOutputCall),
3260 #[allow(missing_docs)]
3261 validateOutputHash(validateOutputHashCall),
3262 #[allow(missing_docs)]
3263 wasOutputExecuted(wasOutputExecutedCall),
3264 }
3265 impl IApplicationCalls {
3266 pub const SELECTORS: &'static [[u8; 4usize]] = &[
3273 [8u8, 235u8, 137u8, 171u8],
3274 [51u8, 19u8, 123u8, 118u8],
3275 [97u8, 177u8, 44u8, 102u8],
3276 [113u8, 80u8, 24u8, 166u8],
3277 [113u8, 137u8, 29u8, 176u8],
3278 [141u8, 165u8, 203u8, 91u8],
3279 [169u8, 77u8, 252u8, 90u8],
3280 [179u8, 161u8, 172u8, 216u8],
3281 [191u8, 138u8, 191u8, 248u8],
3282 [230u8, 79u8, 171u8, 77u8],
3283 [232u8, 141u8, 57u8, 192u8],
3284 [240u8, 36u8, 120u8, 222u8],
3285 [242u8, 253u8, 227u8, 139u8],
3286 ];
3287 pub const VARIANT_NAMES: &'static [&'static str] = &[
3289 ::core::stringify!(validateOutputHash),
3290 ::core::stringify!(executeOutput),
3291 ::core::stringify!(getTemplateHash),
3292 ::core::stringify!(renounceOwnership),
3293 ::core::stringify!(wasOutputExecuted),
3294 ::core::stringify!(owner),
3295 ::core::stringify!(getOutputsMerkleRootValidator),
3296 ::core::stringify!(getDeploymentBlockNumber),
3297 ::core::stringify!(migrateToOutputsMerkleRootValidator),
3298 ::core::stringify!(getNumberOfExecutedOutputs),
3299 ::core::stringify!(validateOutput),
3300 ::core::stringify!(getDataAvailability),
3301 ::core::stringify!(transferOwnership),
3302 ];
3303 pub const SIGNATURES: &'static [&'static str] = &[
3305 <validateOutputHashCall as alloy_sol_types::SolCall>::SIGNATURE,
3306 <executeOutputCall as alloy_sol_types::SolCall>::SIGNATURE,
3307 <getTemplateHashCall as alloy_sol_types::SolCall>::SIGNATURE,
3308 <renounceOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
3309 <wasOutputExecutedCall as alloy_sol_types::SolCall>::SIGNATURE,
3310 <ownerCall as alloy_sol_types::SolCall>::SIGNATURE,
3311 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::SIGNATURE,
3312 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::SIGNATURE,
3313 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::SIGNATURE,
3314 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::SIGNATURE,
3315 <validateOutputCall as alloy_sol_types::SolCall>::SIGNATURE,
3316 <getDataAvailabilityCall as alloy_sol_types::SolCall>::SIGNATURE,
3317 <transferOwnershipCall as alloy_sol_types::SolCall>::SIGNATURE,
3318 ];
3319 #[inline]
3321 pub fn signature_by_selector(
3322 selector: [u8; 4usize],
3323 ) -> ::core::option::Option<&'static str> {
3324 match Self::SELECTORS.binary_search(&selector) {
3325 ::core::result::Result::Ok(idx) => {
3326 ::core::option::Option::Some(Self::SIGNATURES[idx])
3327 }
3328 ::core::result::Result::Err(_) => ::core::option::Option::None,
3329 }
3330 }
3331 #[inline]
3333 pub fn name_by_selector(
3334 selector: [u8; 4usize],
3335 ) -> ::core::option::Option<&'static str> {
3336 let sig = Self::signature_by_selector(selector)?;
3337 sig.split_once('(').map(|(name, _)| name)
3338 }
3339 }
3340 #[automatically_derived]
3341 impl alloy_sol_types::SolInterface for IApplicationCalls {
3342 const NAME: &'static str = "IApplicationCalls";
3343 const MIN_DATA_LENGTH: usize = 0usize;
3344 const COUNT: usize = 13usize;
3345 #[inline]
3346 fn selector(&self) -> [u8; 4] {
3347 match self {
3348 Self::executeOutput(_) => {
3349 <executeOutputCall as alloy_sol_types::SolCall>::SELECTOR
3350 }
3351 Self::getDataAvailability(_) => {
3352 <getDataAvailabilityCall as alloy_sol_types::SolCall>::SELECTOR
3353 }
3354 Self::getDeploymentBlockNumber(_) => {
3355 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::SELECTOR
3356 }
3357 Self::getNumberOfExecutedOutputs(_) => {
3358 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::SELECTOR
3359 }
3360 Self::getOutputsMerkleRootValidator(_) => {
3361 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::SELECTOR
3362 }
3363 Self::getTemplateHash(_) => {
3364 <getTemplateHashCall as alloy_sol_types::SolCall>::SELECTOR
3365 }
3366 Self::migrateToOutputsMerkleRootValidator(_) => {
3367 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::SELECTOR
3368 }
3369 Self::owner(_) => <ownerCall as alloy_sol_types::SolCall>::SELECTOR,
3370 Self::renounceOwnership(_) => {
3371 <renounceOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
3372 }
3373 Self::transferOwnership(_) => {
3374 <transferOwnershipCall as alloy_sol_types::SolCall>::SELECTOR
3375 }
3376 Self::validateOutput(_) => {
3377 <validateOutputCall as alloy_sol_types::SolCall>::SELECTOR
3378 }
3379 Self::validateOutputHash(_) => {
3380 <validateOutputHashCall as alloy_sol_types::SolCall>::SELECTOR
3381 }
3382 Self::wasOutputExecuted(_) => {
3383 <wasOutputExecutedCall as alloy_sol_types::SolCall>::SELECTOR
3384 }
3385 }
3386 }
3387 #[inline]
3388 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
3389 Self::SELECTORS.get(i).copied()
3390 }
3391 #[inline]
3392 fn valid_selector(selector: [u8; 4]) -> bool {
3393 Self::SELECTORS.binary_search(&selector).is_ok()
3394 }
3395 #[inline]
3396 #[allow(non_snake_case)]
3397 fn abi_decode_raw(
3398 selector: [u8; 4],
3399 data: &[u8],
3400 ) -> alloy_sol_types::Result<Self> {
3401 static DECODE_SHIMS: &[fn(
3402 &[u8],
3403 ) -> alloy_sol_types::Result<IApplicationCalls>] = &[
3404 {
3405 fn validateOutputHash(
3406 data: &[u8],
3407 ) -> alloy_sol_types::Result<IApplicationCalls> {
3408 <validateOutputHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
3409 data,
3410 )
3411 .map(IApplicationCalls::validateOutputHash)
3412 }
3413 validateOutputHash
3414 },
3415 {
3416 fn executeOutput(
3417 data: &[u8],
3418 ) -> alloy_sol_types::Result<IApplicationCalls> {
3419 <executeOutputCall as alloy_sol_types::SolCall>::abi_decode_raw(
3420 data,
3421 )
3422 .map(IApplicationCalls::executeOutput)
3423 }
3424 executeOutput
3425 },
3426 {
3427 fn getTemplateHash(
3428 data: &[u8],
3429 ) -> alloy_sol_types::Result<IApplicationCalls> {
3430 <getTemplateHashCall as alloy_sol_types::SolCall>::abi_decode_raw(
3431 data,
3432 )
3433 .map(IApplicationCalls::getTemplateHash)
3434 }
3435 getTemplateHash
3436 },
3437 {
3438 fn renounceOwnership(
3439 data: &[u8],
3440 ) -> alloy_sol_types::Result<IApplicationCalls> {
3441 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
3442 data,
3443 )
3444 .map(IApplicationCalls::renounceOwnership)
3445 }
3446 renounceOwnership
3447 },
3448 {
3449 fn wasOutputExecuted(
3450 data: &[u8],
3451 ) -> alloy_sol_types::Result<IApplicationCalls> {
3452 <wasOutputExecutedCall as alloy_sol_types::SolCall>::abi_decode_raw(
3453 data,
3454 )
3455 .map(IApplicationCalls::wasOutputExecuted)
3456 }
3457 wasOutputExecuted
3458 },
3459 {
3460 fn owner(data: &[u8]) -> alloy_sol_types::Result<IApplicationCalls> {
3461 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw(data)
3462 .map(IApplicationCalls::owner)
3463 }
3464 owner
3465 },
3466 {
3467 fn getOutputsMerkleRootValidator(
3468 data: &[u8],
3469 ) -> alloy_sol_types::Result<IApplicationCalls> {
3470 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
3471 data,
3472 )
3473 .map(IApplicationCalls::getOutputsMerkleRootValidator)
3474 }
3475 getOutputsMerkleRootValidator
3476 },
3477 {
3478 fn getDeploymentBlockNumber(
3479 data: &[u8],
3480 ) -> alloy_sol_types::Result<IApplicationCalls> {
3481 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw(
3482 data,
3483 )
3484 .map(IApplicationCalls::getDeploymentBlockNumber)
3485 }
3486 getDeploymentBlockNumber
3487 },
3488 {
3489 fn migrateToOutputsMerkleRootValidator(
3490 data: &[u8],
3491 ) -> alloy_sol_types::Result<IApplicationCalls> {
3492 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw(
3493 data,
3494 )
3495 .map(IApplicationCalls::migrateToOutputsMerkleRootValidator)
3496 }
3497 migrateToOutputsMerkleRootValidator
3498 },
3499 {
3500 fn getNumberOfExecutedOutputs(
3501 data: &[u8],
3502 ) -> alloy_sol_types::Result<IApplicationCalls> {
3503 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::abi_decode_raw(
3504 data,
3505 )
3506 .map(IApplicationCalls::getNumberOfExecutedOutputs)
3507 }
3508 getNumberOfExecutedOutputs
3509 },
3510 {
3511 fn validateOutput(
3512 data: &[u8],
3513 ) -> alloy_sol_types::Result<IApplicationCalls> {
3514 <validateOutputCall as alloy_sol_types::SolCall>::abi_decode_raw(
3515 data,
3516 )
3517 .map(IApplicationCalls::validateOutput)
3518 }
3519 validateOutput
3520 },
3521 {
3522 fn getDataAvailability(
3523 data: &[u8],
3524 ) -> alloy_sol_types::Result<IApplicationCalls> {
3525 <getDataAvailabilityCall as alloy_sol_types::SolCall>::abi_decode_raw(
3526 data,
3527 )
3528 .map(IApplicationCalls::getDataAvailability)
3529 }
3530 getDataAvailability
3531 },
3532 {
3533 fn transferOwnership(
3534 data: &[u8],
3535 ) -> alloy_sol_types::Result<IApplicationCalls> {
3536 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw(
3537 data,
3538 )
3539 .map(IApplicationCalls::transferOwnership)
3540 }
3541 transferOwnership
3542 },
3543 ];
3544 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3545 return Err(
3546 alloy_sol_types::Error::unknown_selector(
3547 <Self as alloy_sol_types::SolInterface>::NAME,
3548 selector,
3549 ),
3550 );
3551 };
3552 DECODE_SHIMS[idx](data)
3553 }
3554 #[inline]
3555 #[allow(non_snake_case)]
3556 fn abi_decode_raw_validate(
3557 selector: [u8; 4],
3558 data: &[u8],
3559 ) -> alloy_sol_types::Result<Self> {
3560 static DECODE_VALIDATE_SHIMS: &[fn(
3561 &[u8],
3562 ) -> alloy_sol_types::Result<IApplicationCalls>] = &[
3563 {
3564 fn validateOutputHash(
3565 data: &[u8],
3566 ) -> alloy_sol_types::Result<IApplicationCalls> {
3567 <validateOutputHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3568 data,
3569 )
3570 .map(IApplicationCalls::validateOutputHash)
3571 }
3572 validateOutputHash
3573 },
3574 {
3575 fn executeOutput(
3576 data: &[u8],
3577 ) -> alloy_sol_types::Result<IApplicationCalls> {
3578 <executeOutputCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3579 data,
3580 )
3581 .map(IApplicationCalls::executeOutput)
3582 }
3583 executeOutput
3584 },
3585 {
3586 fn getTemplateHash(
3587 data: &[u8],
3588 ) -> alloy_sol_types::Result<IApplicationCalls> {
3589 <getTemplateHashCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3590 data,
3591 )
3592 .map(IApplicationCalls::getTemplateHash)
3593 }
3594 getTemplateHash
3595 },
3596 {
3597 fn renounceOwnership(
3598 data: &[u8],
3599 ) -> alloy_sol_types::Result<IApplicationCalls> {
3600 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3601 data,
3602 )
3603 .map(IApplicationCalls::renounceOwnership)
3604 }
3605 renounceOwnership
3606 },
3607 {
3608 fn wasOutputExecuted(
3609 data: &[u8],
3610 ) -> alloy_sol_types::Result<IApplicationCalls> {
3611 <wasOutputExecutedCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3612 data,
3613 )
3614 .map(IApplicationCalls::wasOutputExecuted)
3615 }
3616 wasOutputExecuted
3617 },
3618 {
3619 fn owner(data: &[u8]) -> alloy_sol_types::Result<IApplicationCalls> {
3620 <ownerCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3621 data,
3622 )
3623 .map(IApplicationCalls::owner)
3624 }
3625 owner
3626 },
3627 {
3628 fn getOutputsMerkleRootValidator(
3629 data: &[u8],
3630 ) -> alloy_sol_types::Result<IApplicationCalls> {
3631 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3632 data,
3633 )
3634 .map(IApplicationCalls::getOutputsMerkleRootValidator)
3635 }
3636 getOutputsMerkleRootValidator
3637 },
3638 {
3639 fn getDeploymentBlockNumber(
3640 data: &[u8],
3641 ) -> alloy_sol_types::Result<IApplicationCalls> {
3642 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3643 data,
3644 )
3645 .map(IApplicationCalls::getDeploymentBlockNumber)
3646 }
3647 getDeploymentBlockNumber
3648 },
3649 {
3650 fn migrateToOutputsMerkleRootValidator(
3651 data: &[u8],
3652 ) -> alloy_sol_types::Result<IApplicationCalls> {
3653 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3654 data,
3655 )
3656 .map(IApplicationCalls::migrateToOutputsMerkleRootValidator)
3657 }
3658 migrateToOutputsMerkleRootValidator
3659 },
3660 {
3661 fn getNumberOfExecutedOutputs(
3662 data: &[u8],
3663 ) -> alloy_sol_types::Result<IApplicationCalls> {
3664 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3665 data,
3666 )
3667 .map(IApplicationCalls::getNumberOfExecutedOutputs)
3668 }
3669 getNumberOfExecutedOutputs
3670 },
3671 {
3672 fn validateOutput(
3673 data: &[u8],
3674 ) -> alloy_sol_types::Result<IApplicationCalls> {
3675 <validateOutputCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3676 data,
3677 )
3678 .map(IApplicationCalls::validateOutput)
3679 }
3680 validateOutput
3681 },
3682 {
3683 fn getDataAvailability(
3684 data: &[u8],
3685 ) -> alloy_sol_types::Result<IApplicationCalls> {
3686 <getDataAvailabilityCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3687 data,
3688 )
3689 .map(IApplicationCalls::getDataAvailability)
3690 }
3691 getDataAvailability
3692 },
3693 {
3694 fn transferOwnership(
3695 data: &[u8],
3696 ) -> alloy_sol_types::Result<IApplicationCalls> {
3697 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
3698 data,
3699 )
3700 .map(IApplicationCalls::transferOwnership)
3701 }
3702 transferOwnership
3703 },
3704 ];
3705 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3706 return Err(
3707 alloy_sol_types::Error::unknown_selector(
3708 <Self as alloy_sol_types::SolInterface>::NAME,
3709 selector,
3710 ),
3711 );
3712 };
3713 DECODE_VALIDATE_SHIMS[idx](data)
3714 }
3715 #[inline]
3716 fn abi_encoded_size(&self) -> usize {
3717 match self {
3718 Self::executeOutput(inner) => {
3719 <executeOutputCall as alloy_sol_types::SolCall>::abi_encoded_size(
3720 inner,
3721 )
3722 }
3723 Self::getDataAvailability(inner) => {
3724 <getDataAvailabilityCall as alloy_sol_types::SolCall>::abi_encoded_size(
3725 inner,
3726 )
3727 }
3728 Self::getDeploymentBlockNumber(inner) => {
3729 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_encoded_size(
3730 inner,
3731 )
3732 }
3733 Self::getNumberOfExecutedOutputs(inner) => {
3734 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::abi_encoded_size(
3735 inner,
3736 )
3737 }
3738 Self::getOutputsMerkleRootValidator(inner) => {
3739 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
3740 inner,
3741 )
3742 }
3743 Self::getTemplateHash(inner) => {
3744 <getTemplateHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
3745 inner,
3746 )
3747 }
3748 Self::migrateToOutputsMerkleRootValidator(inner) => {
3749 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_encoded_size(
3750 inner,
3751 )
3752 }
3753 Self::owner(inner) => {
3754 <ownerCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
3755 }
3756 Self::renounceOwnership(inner) => {
3757 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
3758 inner,
3759 )
3760 }
3761 Self::transferOwnership(inner) => {
3762 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encoded_size(
3763 inner,
3764 )
3765 }
3766 Self::validateOutput(inner) => {
3767 <validateOutputCall as alloy_sol_types::SolCall>::abi_encoded_size(
3768 inner,
3769 )
3770 }
3771 Self::validateOutputHash(inner) => {
3772 <validateOutputHashCall as alloy_sol_types::SolCall>::abi_encoded_size(
3773 inner,
3774 )
3775 }
3776 Self::wasOutputExecuted(inner) => {
3777 <wasOutputExecutedCall as alloy_sol_types::SolCall>::abi_encoded_size(
3778 inner,
3779 )
3780 }
3781 }
3782 }
3783 #[inline]
3784 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
3785 match self {
3786 Self::executeOutput(inner) => {
3787 <executeOutputCall as alloy_sol_types::SolCall>::abi_encode_raw(
3788 inner,
3789 out,
3790 )
3791 }
3792 Self::getDataAvailability(inner) => {
3793 <getDataAvailabilityCall as alloy_sol_types::SolCall>::abi_encode_raw(
3794 inner,
3795 out,
3796 )
3797 }
3798 Self::getDeploymentBlockNumber(inner) => {
3799 <getDeploymentBlockNumberCall as alloy_sol_types::SolCall>::abi_encode_raw(
3800 inner,
3801 out,
3802 )
3803 }
3804 Self::getNumberOfExecutedOutputs(inner) => {
3805 <getNumberOfExecutedOutputsCall as alloy_sol_types::SolCall>::abi_encode_raw(
3806 inner,
3807 out,
3808 )
3809 }
3810 Self::getOutputsMerkleRootValidator(inner) => {
3811 <getOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
3812 inner,
3813 out,
3814 )
3815 }
3816 Self::getTemplateHash(inner) => {
3817 <getTemplateHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
3818 inner,
3819 out,
3820 )
3821 }
3822 Self::migrateToOutputsMerkleRootValidator(inner) => {
3823 <migrateToOutputsMerkleRootValidatorCall as alloy_sol_types::SolCall>::abi_encode_raw(
3824 inner,
3825 out,
3826 )
3827 }
3828 Self::owner(inner) => {
3829 <ownerCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
3830 }
3831 Self::renounceOwnership(inner) => {
3832 <renounceOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
3833 inner,
3834 out,
3835 )
3836 }
3837 Self::transferOwnership(inner) => {
3838 <transferOwnershipCall as alloy_sol_types::SolCall>::abi_encode_raw(
3839 inner,
3840 out,
3841 )
3842 }
3843 Self::validateOutput(inner) => {
3844 <validateOutputCall as alloy_sol_types::SolCall>::abi_encode_raw(
3845 inner,
3846 out,
3847 )
3848 }
3849 Self::validateOutputHash(inner) => {
3850 <validateOutputHashCall as alloy_sol_types::SolCall>::abi_encode_raw(
3851 inner,
3852 out,
3853 )
3854 }
3855 Self::wasOutputExecuted(inner) => {
3856 <wasOutputExecutedCall as alloy_sol_types::SolCall>::abi_encode_raw(
3857 inner,
3858 out,
3859 )
3860 }
3861 }
3862 }
3863 }
3864 #[derive(Clone)]
3866 #[derive(serde::Serialize, serde::Deserialize)]
3867 #[derive(Debug, PartialEq, Eq, Hash)]
3868 pub enum IApplicationErrors {
3869 #[allow(missing_docs)]
3870 InsufficientFunds(InsufficientFunds),
3871 #[allow(missing_docs)]
3872 InvalidOutputHashesSiblingsArrayLength(InvalidOutputHashesSiblingsArrayLength),
3873 #[allow(missing_docs)]
3874 InvalidOutputsMerkleRoot(InvalidOutputsMerkleRoot),
3875 #[allow(missing_docs)]
3876 OutputNotExecutable(OutputNotExecutable),
3877 #[allow(missing_docs)]
3878 OutputNotReexecutable(OutputNotReexecutable),
3879 }
3880 impl IApplicationErrors {
3881 pub const SELECTORS: &'static [[u8; 4usize]] = &[
3888 [3u8, 235u8, 139u8, 84u8],
3889 [68u8, 161u8, 146u8, 255u8],
3890 [123u8, 151u8, 166u8, 187u8],
3891 [186u8, 88u8, 189u8, 54u8],
3892 [210u8, 132u8, 192u8, 30u8],
3893 ];
3894 pub const VARIANT_NAMES: &'static [&'static str] = &[
3896 ::core::stringify!(InsufficientFunds),
3897 ::core::stringify!(InvalidOutputsMerkleRoot),
3898 ::core::stringify!(OutputNotReexecutable),
3899 ::core::stringify!(InvalidOutputHashesSiblingsArrayLength),
3900 ::core::stringify!(OutputNotExecutable),
3901 ];
3902 pub const SIGNATURES: &'static [&'static str] = &[
3904 <InsufficientFunds as alloy_sol_types::SolError>::SIGNATURE,
3905 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::SIGNATURE,
3906 <OutputNotReexecutable as alloy_sol_types::SolError>::SIGNATURE,
3907 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::SIGNATURE,
3908 <OutputNotExecutable as alloy_sol_types::SolError>::SIGNATURE,
3909 ];
3910 #[inline]
3912 pub fn signature_by_selector(
3913 selector: [u8; 4usize],
3914 ) -> ::core::option::Option<&'static str> {
3915 match Self::SELECTORS.binary_search(&selector) {
3916 ::core::result::Result::Ok(idx) => {
3917 ::core::option::Option::Some(Self::SIGNATURES[idx])
3918 }
3919 ::core::result::Result::Err(_) => ::core::option::Option::None,
3920 }
3921 }
3922 #[inline]
3924 pub fn name_by_selector(
3925 selector: [u8; 4usize],
3926 ) -> ::core::option::Option<&'static str> {
3927 let sig = Self::signature_by_selector(selector)?;
3928 sig.split_once('(').map(|(name, _)| name)
3929 }
3930 }
3931 #[automatically_derived]
3932 impl alloy_sol_types::SolInterface for IApplicationErrors {
3933 const NAME: &'static str = "IApplicationErrors";
3934 const MIN_DATA_LENGTH: usize = 0usize;
3935 const COUNT: usize = 5usize;
3936 #[inline]
3937 fn selector(&self) -> [u8; 4] {
3938 match self {
3939 Self::InsufficientFunds(_) => {
3940 <InsufficientFunds as alloy_sol_types::SolError>::SELECTOR
3941 }
3942 Self::InvalidOutputHashesSiblingsArrayLength(_) => {
3943 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::SELECTOR
3944 }
3945 Self::InvalidOutputsMerkleRoot(_) => {
3946 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::SELECTOR
3947 }
3948 Self::OutputNotExecutable(_) => {
3949 <OutputNotExecutable as alloy_sol_types::SolError>::SELECTOR
3950 }
3951 Self::OutputNotReexecutable(_) => {
3952 <OutputNotReexecutable as alloy_sol_types::SolError>::SELECTOR
3953 }
3954 }
3955 }
3956 #[inline]
3957 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
3958 Self::SELECTORS.get(i).copied()
3959 }
3960 #[inline]
3961 fn valid_selector(selector: [u8; 4]) -> bool {
3962 Self::SELECTORS.binary_search(&selector).is_ok()
3963 }
3964 #[inline]
3965 #[allow(non_snake_case)]
3966 fn abi_decode_raw(
3967 selector: [u8; 4],
3968 data: &[u8],
3969 ) -> alloy_sol_types::Result<Self> {
3970 static DECODE_SHIMS: &[fn(
3971 &[u8],
3972 ) -> alloy_sol_types::Result<IApplicationErrors>] = &[
3973 {
3974 fn InsufficientFunds(
3975 data: &[u8],
3976 ) -> alloy_sol_types::Result<IApplicationErrors> {
3977 <InsufficientFunds as alloy_sol_types::SolError>::abi_decode_raw(
3978 data,
3979 )
3980 .map(IApplicationErrors::InsufficientFunds)
3981 }
3982 InsufficientFunds
3983 },
3984 {
3985 fn InvalidOutputsMerkleRoot(
3986 data: &[u8],
3987 ) -> alloy_sol_types::Result<IApplicationErrors> {
3988 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::abi_decode_raw(
3989 data,
3990 )
3991 .map(IApplicationErrors::InvalidOutputsMerkleRoot)
3992 }
3993 InvalidOutputsMerkleRoot
3994 },
3995 {
3996 fn OutputNotReexecutable(
3997 data: &[u8],
3998 ) -> alloy_sol_types::Result<IApplicationErrors> {
3999 <OutputNotReexecutable as alloy_sol_types::SolError>::abi_decode_raw(
4000 data,
4001 )
4002 .map(IApplicationErrors::OutputNotReexecutable)
4003 }
4004 OutputNotReexecutable
4005 },
4006 {
4007 fn InvalidOutputHashesSiblingsArrayLength(
4008 data: &[u8],
4009 ) -> alloy_sol_types::Result<IApplicationErrors> {
4010 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::abi_decode_raw(
4011 data,
4012 )
4013 .map(
4014 IApplicationErrors::InvalidOutputHashesSiblingsArrayLength,
4015 )
4016 }
4017 InvalidOutputHashesSiblingsArrayLength
4018 },
4019 {
4020 fn OutputNotExecutable(
4021 data: &[u8],
4022 ) -> alloy_sol_types::Result<IApplicationErrors> {
4023 <OutputNotExecutable as alloy_sol_types::SolError>::abi_decode_raw(
4024 data,
4025 )
4026 .map(IApplicationErrors::OutputNotExecutable)
4027 }
4028 OutputNotExecutable
4029 },
4030 ];
4031 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4032 return Err(
4033 alloy_sol_types::Error::unknown_selector(
4034 <Self as alloy_sol_types::SolInterface>::NAME,
4035 selector,
4036 ),
4037 );
4038 };
4039 DECODE_SHIMS[idx](data)
4040 }
4041 #[inline]
4042 #[allow(non_snake_case)]
4043 fn abi_decode_raw_validate(
4044 selector: [u8; 4],
4045 data: &[u8],
4046 ) -> alloy_sol_types::Result<Self> {
4047 static DECODE_VALIDATE_SHIMS: &[fn(
4048 &[u8],
4049 ) -> alloy_sol_types::Result<IApplicationErrors>] = &[
4050 {
4051 fn InsufficientFunds(
4052 data: &[u8],
4053 ) -> alloy_sol_types::Result<IApplicationErrors> {
4054 <InsufficientFunds as alloy_sol_types::SolError>::abi_decode_raw_validate(
4055 data,
4056 )
4057 .map(IApplicationErrors::InsufficientFunds)
4058 }
4059 InsufficientFunds
4060 },
4061 {
4062 fn InvalidOutputsMerkleRoot(
4063 data: &[u8],
4064 ) -> alloy_sol_types::Result<IApplicationErrors> {
4065 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::abi_decode_raw_validate(
4066 data,
4067 )
4068 .map(IApplicationErrors::InvalidOutputsMerkleRoot)
4069 }
4070 InvalidOutputsMerkleRoot
4071 },
4072 {
4073 fn OutputNotReexecutable(
4074 data: &[u8],
4075 ) -> alloy_sol_types::Result<IApplicationErrors> {
4076 <OutputNotReexecutable as alloy_sol_types::SolError>::abi_decode_raw_validate(
4077 data,
4078 )
4079 .map(IApplicationErrors::OutputNotReexecutable)
4080 }
4081 OutputNotReexecutable
4082 },
4083 {
4084 fn InvalidOutputHashesSiblingsArrayLength(
4085 data: &[u8],
4086 ) -> alloy_sol_types::Result<IApplicationErrors> {
4087 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::abi_decode_raw_validate(
4088 data,
4089 )
4090 .map(
4091 IApplicationErrors::InvalidOutputHashesSiblingsArrayLength,
4092 )
4093 }
4094 InvalidOutputHashesSiblingsArrayLength
4095 },
4096 {
4097 fn OutputNotExecutable(
4098 data: &[u8],
4099 ) -> alloy_sol_types::Result<IApplicationErrors> {
4100 <OutputNotExecutable as alloy_sol_types::SolError>::abi_decode_raw_validate(
4101 data,
4102 )
4103 .map(IApplicationErrors::OutputNotExecutable)
4104 }
4105 OutputNotExecutable
4106 },
4107 ];
4108 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4109 return Err(
4110 alloy_sol_types::Error::unknown_selector(
4111 <Self as alloy_sol_types::SolInterface>::NAME,
4112 selector,
4113 ),
4114 );
4115 };
4116 DECODE_VALIDATE_SHIMS[idx](data)
4117 }
4118 #[inline]
4119 fn abi_encoded_size(&self) -> usize {
4120 match self {
4121 Self::InsufficientFunds(inner) => {
4122 <InsufficientFunds as alloy_sol_types::SolError>::abi_encoded_size(
4123 inner,
4124 )
4125 }
4126 Self::InvalidOutputHashesSiblingsArrayLength(inner) => {
4127 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::abi_encoded_size(
4128 inner,
4129 )
4130 }
4131 Self::InvalidOutputsMerkleRoot(inner) => {
4132 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::abi_encoded_size(
4133 inner,
4134 )
4135 }
4136 Self::OutputNotExecutable(inner) => {
4137 <OutputNotExecutable as alloy_sol_types::SolError>::abi_encoded_size(
4138 inner,
4139 )
4140 }
4141 Self::OutputNotReexecutable(inner) => {
4142 <OutputNotReexecutable as alloy_sol_types::SolError>::abi_encoded_size(
4143 inner,
4144 )
4145 }
4146 }
4147 }
4148 #[inline]
4149 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4150 match self {
4151 Self::InsufficientFunds(inner) => {
4152 <InsufficientFunds as alloy_sol_types::SolError>::abi_encode_raw(
4153 inner,
4154 out,
4155 )
4156 }
4157 Self::InvalidOutputHashesSiblingsArrayLength(inner) => {
4158 <InvalidOutputHashesSiblingsArrayLength as alloy_sol_types::SolError>::abi_encode_raw(
4159 inner,
4160 out,
4161 )
4162 }
4163 Self::InvalidOutputsMerkleRoot(inner) => {
4164 <InvalidOutputsMerkleRoot as alloy_sol_types::SolError>::abi_encode_raw(
4165 inner,
4166 out,
4167 )
4168 }
4169 Self::OutputNotExecutable(inner) => {
4170 <OutputNotExecutable as alloy_sol_types::SolError>::abi_encode_raw(
4171 inner,
4172 out,
4173 )
4174 }
4175 Self::OutputNotReexecutable(inner) => {
4176 <OutputNotReexecutable as alloy_sol_types::SolError>::abi_encode_raw(
4177 inner,
4178 out,
4179 )
4180 }
4181 }
4182 }
4183 }
4184 #[derive(Clone)]
4186 #[derive(serde::Serialize, serde::Deserialize)]
4187 #[derive(Debug, PartialEq, Eq, Hash)]
4188 pub enum IApplicationEvents {
4189 #[allow(missing_docs)]
4190 OutputExecuted(OutputExecuted),
4191 #[allow(missing_docs)]
4192 OutputsMerkleRootValidatorChanged(OutputsMerkleRootValidatorChanged),
4193 }
4194 impl IApplicationEvents {
4195 pub const SELECTORS: &'static [[u8; 32usize]] = &[
4202 [
4203 106u8, 211u8, 24u8, 139u8, 168u8, 244u8, 48u8, 251u8, 160u8, 101u8,
4204 108u8, 176u8, 167u8, 232u8, 57u8, 171u8, 32u8, 32u8, 213u8, 88u8, 107u8,
4205 161u8, 26u8, 20u8, 119u8, 209u8, 143u8, 112u8, 146u8, 248u8, 190u8, 206u8,
4206 ],
4207 [
4208 202u8, 209u8, 243u8, 97u8, 198u8, 232u8, 70u8, 100u8, 232u8, 146u8, 35u8,
4209 2u8, 145u8, 200u8, 232u8, 235u8, 149u8, 85u8, 104u8, 62u8, 10u8, 106u8,
4210 92u8, 232u8, 234u8, 123u8, 32u8, 74u8, 192u8, 172u8, 54u8, 118u8,
4211 ],
4212 ];
4213 pub const VARIANT_NAMES: &'static [&'static str] = &[
4215 ::core::stringify!(OutputsMerkleRootValidatorChanged),
4216 ::core::stringify!(OutputExecuted),
4217 ];
4218 pub const SIGNATURES: &'static [&'static str] = &[
4220 <OutputsMerkleRootValidatorChanged as alloy_sol_types::SolEvent>::SIGNATURE,
4221 <OutputExecuted as alloy_sol_types::SolEvent>::SIGNATURE,
4222 ];
4223 #[inline]
4225 pub fn signature_by_selector(
4226 selector: [u8; 32usize],
4227 ) -> ::core::option::Option<&'static str> {
4228 match Self::SELECTORS.binary_search(&selector) {
4229 ::core::result::Result::Ok(idx) => {
4230 ::core::option::Option::Some(Self::SIGNATURES[idx])
4231 }
4232 ::core::result::Result::Err(_) => ::core::option::Option::None,
4233 }
4234 }
4235 #[inline]
4237 pub fn name_by_selector(
4238 selector: [u8; 32usize],
4239 ) -> ::core::option::Option<&'static str> {
4240 let sig = Self::signature_by_selector(selector)?;
4241 sig.split_once('(').map(|(name, _)| name)
4242 }
4243 }
4244 #[automatically_derived]
4245 impl alloy_sol_types::SolEventInterface for IApplicationEvents {
4246 const NAME: &'static str = "IApplicationEvents";
4247 const COUNT: usize = 2usize;
4248 fn decode_raw_log(
4249 topics: &[alloy_sol_types::Word],
4250 data: &[u8],
4251 ) -> alloy_sol_types::Result<Self> {
4252 match topics.first().copied() {
4253 Some(<OutputExecuted as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
4254 <OutputExecuted as alloy_sol_types::SolEvent>::decode_raw_log(
4255 topics,
4256 data,
4257 )
4258 .map(Self::OutputExecuted)
4259 }
4260 Some(
4261 <OutputsMerkleRootValidatorChanged as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
4262 ) => {
4263 <OutputsMerkleRootValidatorChanged as alloy_sol_types::SolEvent>::decode_raw_log(
4264 topics,
4265 data,
4266 )
4267 .map(Self::OutputsMerkleRootValidatorChanged)
4268 }
4269 _ => {
4270 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
4271 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
4272 log: alloy_sol_types::private::Box::new(
4273 alloy_sol_types::private::LogData::new_unchecked(
4274 topics.to_vec(),
4275 data.to_vec().into(),
4276 ),
4277 ),
4278 })
4279 }
4280 }
4281 }
4282 }
4283 #[automatically_derived]
4284 impl alloy_sol_types::private::IntoLogData for IApplicationEvents {
4285 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
4286 match self {
4287 Self::OutputExecuted(inner) => {
4288 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4289 }
4290 Self::OutputsMerkleRootValidatorChanged(inner) => {
4291 alloy_sol_types::private::IntoLogData::to_log_data(inner)
4292 }
4293 }
4294 }
4295 fn into_log_data(self) -> alloy_sol_types::private::LogData {
4296 match self {
4297 Self::OutputExecuted(inner) => {
4298 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4299 }
4300 Self::OutputsMerkleRootValidatorChanged(inner) => {
4301 alloy_sol_types::private::IntoLogData::into_log_data(inner)
4302 }
4303 }
4304 }
4305 }
4306 use alloy::contract as alloy_contract;
4307 #[inline]
4311 pub const fn new<
4312 P: alloy_contract::private::Provider<N>,
4313 N: alloy_contract::private::Network,
4314 >(
4315 address: alloy_sol_types::private::Address,
4316 __provider: P,
4317 ) -> IApplicationInstance<P, N> {
4318 IApplicationInstance::<P, N>::new(address, __provider)
4319 }
4320 #[inline]
4326 pub fn deploy<
4327 P: alloy_contract::private::Provider<N>,
4328 N: alloy_contract::private::Network,
4329 >(
4330 __provider: P,
4331 ) -> impl ::core::future::Future<
4332 Output = alloy_contract::Result<IApplicationInstance<P, N>>,
4333 > {
4334 IApplicationInstance::<P, N>::deploy(__provider)
4335 }
4336 #[inline]
4342 pub fn deploy_builder<
4343 P: alloy_contract::private::Provider<N>,
4344 N: alloy_contract::private::Network,
4345 >(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
4346 IApplicationInstance::<P, N>::deploy_builder(__provider)
4347 }
4348 #[derive(Clone)]
4360 pub struct IApplicationInstance<P, N = alloy_contract::private::Ethereum> {
4361 address: alloy_sol_types::private::Address,
4362 provider: P,
4363 _network: ::core::marker::PhantomData<N>,
4364 }
4365 #[automatically_derived]
4366 impl<P, N> ::core::fmt::Debug for IApplicationInstance<P, N> {
4367 #[inline]
4368 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
4369 f.debug_tuple("IApplicationInstance").field(&self.address).finish()
4370 }
4371 }
4372 impl<
4374 P: alloy_contract::private::Provider<N>,
4375 N: alloy_contract::private::Network,
4376 > IApplicationInstance<P, N> {
4377 #[inline]
4381 pub const fn new(
4382 address: alloy_sol_types::private::Address,
4383 __provider: P,
4384 ) -> Self {
4385 Self {
4386 address,
4387 provider: __provider,
4388 _network: ::core::marker::PhantomData,
4389 }
4390 }
4391 #[inline]
4397 pub async fn deploy(
4398 __provider: P,
4399 ) -> alloy_contract::Result<IApplicationInstance<P, N>> {
4400 let call_builder = Self::deploy_builder(__provider);
4401 let contract_address = call_builder.deploy().await?;
4402 Ok(Self::new(contract_address, call_builder.provider))
4403 }
4404 #[inline]
4410 pub fn deploy_builder(__provider: P) -> alloy_contract::RawCallBuilder<P, N> {
4411 alloy_contract::RawCallBuilder::new_raw_deploy(
4412 __provider,
4413 ::core::clone::Clone::clone(&BYTECODE),
4414 )
4415 }
4416 #[inline]
4418 pub const fn address(&self) -> &alloy_sol_types::private::Address {
4419 &self.address
4420 }
4421 #[inline]
4423 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
4424 self.address = address;
4425 }
4426 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
4428 self.set_address(address);
4429 self
4430 }
4431 #[inline]
4433 pub const fn provider(&self) -> &P {
4434 &self.provider
4435 }
4436 }
4437 impl<P: ::core::clone::Clone, N> IApplicationInstance<&P, N> {
4438 #[inline]
4440 pub fn with_cloned_provider(self) -> IApplicationInstance<P, N> {
4441 IApplicationInstance {
4442 address: self.address,
4443 provider: ::core::clone::Clone::clone(&self.provider),
4444 _network: ::core::marker::PhantomData,
4445 }
4446 }
4447 }
4448 impl<
4450 P: alloy_contract::private::Provider<N>,
4451 N: alloy_contract::private::Network,
4452 > IApplicationInstance<P, N> {
4453 pub fn call_builder<C: alloy_sol_types::SolCall>(
4458 &self,
4459 call: &C,
4460 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
4461 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
4462 }
4463 pub fn executeOutput(
4465 &self,
4466 output: alloy::sol_types::private::Bytes,
4467 proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
4468 ) -> alloy_contract::SolCallBuilder<&P, executeOutputCall, N> {
4469 self.call_builder(&executeOutputCall { output, proof })
4470 }
4471 pub fn getDataAvailability(
4473 &self,
4474 ) -> alloy_contract::SolCallBuilder<&P, getDataAvailabilityCall, N> {
4475 self.call_builder(&getDataAvailabilityCall)
4476 }
4477 pub fn getDeploymentBlockNumber(
4479 &self,
4480 ) -> alloy_contract::SolCallBuilder<&P, getDeploymentBlockNumberCall, N> {
4481 self.call_builder(&getDeploymentBlockNumberCall)
4482 }
4483 pub fn getNumberOfExecutedOutputs(
4485 &self,
4486 ) -> alloy_contract::SolCallBuilder<&P, getNumberOfExecutedOutputsCall, N> {
4487 self.call_builder(&getNumberOfExecutedOutputsCall)
4488 }
4489 pub fn getOutputsMerkleRootValidator(
4491 &self,
4492 ) -> alloy_contract::SolCallBuilder<&P, getOutputsMerkleRootValidatorCall, N> {
4493 self.call_builder(&getOutputsMerkleRootValidatorCall)
4494 }
4495 pub fn getTemplateHash(
4497 &self,
4498 ) -> alloy_contract::SolCallBuilder<&P, getTemplateHashCall, N> {
4499 self.call_builder(&getTemplateHashCall)
4500 }
4501 pub fn migrateToOutputsMerkleRootValidator(
4503 &self,
4504 newOutputsMerkleRootValidator: alloy::sol_types::private::Address,
4505 ) -> alloy_contract::SolCallBuilder<
4506 &P,
4507 migrateToOutputsMerkleRootValidatorCall,
4508 N,
4509 > {
4510 self.call_builder(
4511 &migrateToOutputsMerkleRootValidatorCall {
4512 newOutputsMerkleRootValidator,
4513 },
4514 )
4515 }
4516 pub fn owner(&self) -> alloy_contract::SolCallBuilder<&P, ownerCall, N> {
4518 self.call_builder(&ownerCall)
4519 }
4520 pub fn renounceOwnership(
4522 &self,
4523 ) -> alloy_contract::SolCallBuilder<&P, renounceOwnershipCall, N> {
4524 self.call_builder(&renounceOwnershipCall)
4525 }
4526 pub fn transferOwnership(
4528 &self,
4529 newOwner: alloy::sol_types::private::Address,
4530 ) -> alloy_contract::SolCallBuilder<&P, transferOwnershipCall, N> {
4531 self.call_builder(&transferOwnershipCall { newOwner })
4532 }
4533 pub fn validateOutput(
4535 &self,
4536 output: alloy::sol_types::private::Bytes,
4537 proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
4538 ) -> alloy_contract::SolCallBuilder<&P, validateOutputCall, N> {
4539 self.call_builder(
4540 &validateOutputCall {
4541 output,
4542 proof,
4543 },
4544 )
4545 }
4546 pub fn validateOutputHash(
4548 &self,
4549 outputHash: alloy::sol_types::private::FixedBytes<32>,
4550 proof: <OutputValidityProof as alloy::sol_types::SolType>::RustType,
4551 ) -> alloy_contract::SolCallBuilder<&P, validateOutputHashCall, N> {
4552 self.call_builder(
4553 &validateOutputHashCall {
4554 outputHash,
4555 proof,
4556 },
4557 )
4558 }
4559 pub fn wasOutputExecuted(
4561 &self,
4562 outputIndex: alloy::sol_types::private::primitives::aliases::U256,
4563 ) -> alloy_contract::SolCallBuilder<&P, wasOutputExecutedCall, N> {
4564 self.call_builder(
4565 &wasOutputExecutedCall {
4566 outputIndex,
4567 },
4568 )
4569 }
4570 }
4571 impl<
4573 P: alloy_contract::private::Provider<N>,
4574 N: alloy_contract::private::Network,
4575 > IApplicationInstance<P, N> {
4576 pub fn event_filter<E: alloy_sol_types::SolEvent>(
4581 &self,
4582 ) -> alloy_contract::Event<&P, E, N> {
4583 alloy_contract::Event::new_sol(&self.provider, &self.address)
4584 }
4585 pub fn OutputExecuted_filter(
4587 &self,
4588 ) -> alloy_contract::Event<&P, OutputExecuted, N> {
4589 self.event_filter::<OutputExecuted>()
4590 }
4591 pub fn OutputsMerkleRootValidatorChanged_filter(
4593 &self,
4594 ) -> alloy_contract::Event<&P, OutputsMerkleRootValidatorChanged, N> {
4595 self.event_filter::<OutputsMerkleRootValidatorChanged>()
4596 }
4597 }
4598}