1#[allow(
390 non_camel_case_types,
391 non_snake_case,
392 clippy::pub_underscore_fields,
393 clippy::style,
394 clippy::empty_structs_with_brackets
395)]
396pub mod HoprCapabilityPermissions {
397 use super::*;
398 use alloy::sol_types as alloy_sol_types;
399 #[rustfmt::skip]
405 #[allow(clippy::all)]
406 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
407 b"a\x011a\0:`\x0B\x82\x82\x829\x80Q`\0\x1A`s\x14a\0-WcNH{q`\xE0\x1B`\0R`\0`\x04R`$`\0\xFD[0`\0R`s\x81S\x82\x81\xF3\xFEs\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R`\x046\x10`~W`\x005`\xE0\x1C\x80czuq\x15\x11`_W\x80czuq\x15\x14`\xC7W\x80c\x81g\xB6~\x14`\xD4W\x80c\xA0\x86X9\x14`\xE1W\x80c\xB6w\xA4\x0F\x14`\xEEW`\0\x80\xFD[\x80cQ\xD2aK\x14`\x83W\x80c]\xAA\x9E$\x14`\xADW\x80cg\x8A^\xFB\x14`\xBAW[`\0\x80\xFD[`\x90c\x06lF\xB9`\xE1\x1B\x81V[`@Q`\x01`\x01`\xE0\x1B\x03\x19\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[`\x90c\xBD\xA6_E`\xE0\x1B\x81V[`\x90cT\xA2\xED\xF5`\xE0\x1B\x81V[`\x90cM\xEC\xDD\xE3`\xE1\x1B\x81V[`\x90ce\x15\x14\xBF`\xE0\x1B\x81V[`\x90c\t^\xA7\xB3`\xE0\x1B\x81V[`\x90c\n\xBE\xC5\x8F`\xE0\x1B\x81V\xFE\xA2dipfsX\"\x12 \xC6&\x98m\xD6\xF3\x03\xC5Q\xE2g\xF4\x1C\xED\x8A<~\xFF\xD4\x9AC j\x04\x8A\x13/\xC6\x88e\xF8LdsolcC\0\x08\x13\x003",
408 );
409 #[rustfmt::skip]
415 #[allow(clippy::all)]
416 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
417 b"s\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\x000\x14`\x80`@R`\x046\x10`~W`\x005`\xE0\x1C\x80czuq\x15\x11`_W\x80czuq\x15\x14`\xC7W\x80c\x81g\xB6~\x14`\xD4W\x80c\xA0\x86X9\x14`\xE1W\x80c\xB6w\xA4\x0F\x14`\xEEW`\0\x80\xFD[\x80cQ\xD2aK\x14`\x83W\x80c]\xAA\x9E$\x14`\xADW\x80cg\x8A^\xFB\x14`\xBAW[`\0\x80\xFD[`\x90c\x06lF\xB9`\xE1\x1B\x81V[`@Q`\x01`\x01`\xE0\x1B\x03\x19\x90\x91\x16\x81R` \x01`@Q\x80\x91\x03\x90\xF3[`\x90c\xBD\xA6_E`\xE0\x1B\x81V[`\x90cT\xA2\xED\xF5`\xE0\x1B\x81V[`\x90cM\xEC\xDD\xE3`\xE1\x1B\x81V[`\x90ce\x15\x14\xBF`\xE0\x1B\x81V[`\x90c\t^\xA7\xB3`\xE0\x1B\x81V[`\x90c\n\xBE\xC5\x8F`\xE0\x1B\x81V\xFE\xA2dipfsX\"\x12 \xC6&\x98m\xD6\xF3\x03\xC5Q\xE2g\xF4\x1C\xED\x8A<~\xFF\xD4\x9AC j\x04\x8A\x13/\xC6\x88e\xF8LdsolcC\0\x08\x13\x003",
418 );
419 #[derive(serde::Serialize, serde::Deserialize)]
420 #[derive(Default, Debug, PartialEq, Eq, Hash)]
421 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
422 #[derive(Clone)]
423 pub struct GranularPermission(u8);
424 const _: () = {
425 use alloy::sol_types as alloy_sol_types;
426 #[automatically_derived]
427 impl alloy_sol_types::private::SolTypeValue<GranularPermission> for u8 {
428 #[inline]
429 fn stv_to_tokens(
430 &self,
431 ) -> <alloy::sol_types::sol_data::Uint<
432 8,
433 > as alloy_sol_types::SolType>::Token<'_> {
434 alloy_sol_types::private::SolTypeValue::<
435 alloy::sol_types::sol_data::Uint<8>,
436 >::stv_to_tokens(self)
437 }
438 #[inline]
439 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
440 <alloy::sol_types::sol_data::Uint<
441 8,
442 > as alloy_sol_types::SolType>::tokenize(self)
443 .0
444 }
445 #[inline]
446 fn stv_abi_encode_packed_to(
447 &self,
448 out: &mut alloy_sol_types::private::Vec<u8>,
449 ) {
450 <alloy::sol_types::sol_data::Uint<
451 8,
452 > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
453 }
454 #[inline]
455 fn stv_abi_packed_encoded_size(&self) -> usize {
456 <alloy::sol_types::sol_data::Uint<
457 8,
458 > as alloy_sol_types::SolType>::abi_encoded_size(self)
459 }
460 }
461 #[automatically_derived]
462 impl GranularPermission {
463 pub const NAME: &'static str = stringify!(@ name);
465 #[inline]
467 pub const fn from_underlying(value: u8) -> Self {
468 Self(value)
469 }
470 #[inline]
472 pub const fn into_underlying(self) -> u8 {
473 self.0
474 }
475 #[inline]
478 pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
479 <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
480 }
481 #[inline]
484 pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
485 <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
486 }
487 }
488 #[automatically_derived]
489 impl From<u8> for GranularPermission {
490 fn from(value: u8) -> Self {
491 Self::from_underlying(value)
492 }
493 }
494 #[automatically_derived]
495 impl From<GranularPermission> for u8 {
496 fn from(value: GranularPermission) -> Self {
497 value.into_underlying()
498 }
499 }
500 #[automatically_derived]
501 impl alloy_sol_types::SolType for GranularPermission {
502 type RustType = u8;
503 type Token<'a> = <alloy::sol_types::sol_data::Uint<
504 8,
505 > as alloy_sol_types::SolType>::Token<'a>;
506 const SOL_NAME: &'static str = Self::NAME;
507 const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
508 8,
509 > as alloy_sol_types::SolType>::ENCODED_SIZE;
510 const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
511 8,
512 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
513 #[inline]
514 fn valid_token(token: &Self::Token<'_>) -> bool {
515 Self::type_check(token).is_ok()
516 }
517 #[inline]
518 fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
519 <alloy::sol_types::sol_data::Uint<
520 8,
521 > as alloy_sol_types::SolType>::type_check(token)
522 }
523 #[inline]
524 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
525 <alloy::sol_types::sol_data::Uint<
526 8,
527 > as alloy_sol_types::SolType>::detokenize(token)
528 }
529 }
530 #[automatically_derived]
531 impl alloy_sol_types::EventTopic for GranularPermission {
532 #[inline]
533 fn topic_preimage_length(rust: &Self::RustType) -> usize {
534 <alloy::sol_types::sol_data::Uint<
535 8,
536 > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
537 }
538 #[inline]
539 fn encode_topic_preimage(
540 rust: &Self::RustType,
541 out: &mut alloy_sol_types::private::Vec<u8>,
542 ) {
543 <alloy::sol_types::sol_data::Uint<
544 8,
545 > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
546 }
547 #[inline]
548 fn encode_topic(
549 rust: &Self::RustType,
550 ) -> alloy_sol_types::abi::token::WordToken {
551 <alloy::sol_types::sol_data::Uint<
552 8,
553 > as alloy_sol_types::EventTopic>::encode_topic(rust)
554 }
555 }
556 };
557 #[derive(serde::Serialize, serde::Deserialize)]
558 #[derive(Default, Debug, PartialEq, Eq, Hash)]
559 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
560 #[derive(Clone)]
561 pub struct Target(alloy::sol_types::private::primitives::aliases::U256);
562 const _: () = {
563 use alloy::sol_types as alloy_sol_types;
564 #[automatically_derived]
565 impl alloy_sol_types::private::SolTypeValue<Target>
566 for alloy::sol_types::private::primitives::aliases::U256 {
567 #[inline]
568 fn stv_to_tokens(
569 &self,
570 ) -> <alloy::sol_types::sol_data::Uint<
571 256,
572 > as alloy_sol_types::SolType>::Token<'_> {
573 alloy_sol_types::private::SolTypeValue::<
574 alloy::sol_types::sol_data::Uint<256>,
575 >::stv_to_tokens(self)
576 }
577 #[inline]
578 fn stv_eip712_data_word(&self) -> alloy_sol_types::Word {
579 <alloy::sol_types::sol_data::Uint<
580 256,
581 > as alloy_sol_types::SolType>::tokenize(self)
582 .0
583 }
584 #[inline]
585 fn stv_abi_encode_packed_to(
586 &self,
587 out: &mut alloy_sol_types::private::Vec<u8>,
588 ) {
589 <alloy::sol_types::sol_data::Uint<
590 256,
591 > as alloy_sol_types::SolType>::abi_encode_packed_to(self, out)
592 }
593 #[inline]
594 fn stv_abi_packed_encoded_size(&self) -> usize {
595 <alloy::sol_types::sol_data::Uint<
596 256,
597 > as alloy_sol_types::SolType>::abi_encoded_size(self)
598 }
599 }
600 #[automatically_derived]
601 impl Target {
602 pub const NAME: &'static str = stringify!(@ name);
604 #[inline]
606 pub const fn from_underlying(
607 value: alloy::sol_types::private::primitives::aliases::U256,
608 ) -> Self {
609 Self(value)
610 }
611 #[inline]
613 pub const fn into_underlying(
614 self,
615 ) -> alloy::sol_types::private::primitives::aliases::U256 {
616 self.0
617 }
618 #[inline]
621 pub fn abi_encode(&self) -> alloy_sol_types::private::Vec<u8> {
622 <Self as alloy_sol_types::SolType>::abi_encode(&self.0)
623 }
624 #[inline]
627 pub fn abi_encode_packed(&self) -> alloy_sol_types::private::Vec<u8> {
628 <Self as alloy_sol_types::SolType>::abi_encode_packed(&self.0)
629 }
630 }
631 #[automatically_derived]
632 impl From<alloy::sol_types::private::primitives::aliases::U256> for Target {
633 fn from(
634 value: alloy::sol_types::private::primitives::aliases::U256,
635 ) -> Self {
636 Self::from_underlying(value)
637 }
638 }
639 #[automatically_derived]
640 impl From<Target> for alloy::sol_types::private::primitives::aliases::U256 {
641 fn from(value: Target) -> Self {
642 value.into_underlying()
643 }
644 }
645 #[automatically_derived]
646 impl alloy_sol_types::SolType for Target {
647 type RustType = alloy::sol_types::private::primitives::aliases::U256;
648 type Token<'a> = <alloy::sol_types::sol_data::Uint<
649 256,
650 > as alloy_sol_types::SolType>::Token<'a>;
651 const SOL_NAME: &'static str = Self::NAME;
652 const ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
653 256,
654 > as alloy_sol_types::SolType>::ENCODED_SIZE;
655 const PACKED_ENCODED_SIZE: Option<usize> = <alloy::sol_types::sol_data::Uint<
656 256,
657 > as alloy_sol_types::SolType>::PACKED_ENCODED_SIZE;
658 #[inline]
659 fn valid_token(token: &Self::Token<'_>) -> bool {
660 Self::type_check(token).is_ok()
661 }
662 #[inline]
663 fn type_check(token: &Self::Token<'_>) -> alloy_sol_types::Result<()> {
664 <alloy::sol_types::sol_data::Uint<
665 256,
666 > as alloy_sol_types::SolType>::type_check(token)
667 }
668 #[inline]
669 fn detokenize(token: Self::Token<'_>) -> Self::RustType {
670 <alloy::sol_types::sol_data::Uint<
671 256,
672 > as alloy_sol_types::SolType>::detokenize(token)
673 }
674 }
675 #[automatically_derived]
676 impl alloy_sol_types::EventTopic for Target {
677 #[inline]
678 fn topic_preimage_length(rust: &Self::RustType) -> usize {
679 <alloy::sol_types::sol_data::Uint<
680 256,
681 > as alloy_sol_types::EventTopic>::topic_preimage_length(rust)
682 }
683 #[inline]
684 fn encode_topic_preimage(
685 rust: &Self::RustType,
686 out: &mut alloy_sol_types::private::Vec<u8>,
687 ) {
688 <alloy::sol_types::sol_data::Uint<
689 256,
690 > as alloy_sol_types::EventTopic>::encode_topic_preimage(rust, out)
691 }
692 #[inline]
693 fn encode_topic(
694 rust: &Self::RustType,
695 ) -> alloy_sol_types::abi::token::WordToken {
696 <alloy::sol_types::sol_data::Uint<
697 256,
698 > as alloy_sol_types::EventTopic>::encode_topic(rust)
699 }
700 }
701 };
702 #[derive(serde::Serialize, serde::Deserialize)]
703 #[derive(Default, Debug, PartialEq, Eq, Hash)]
704 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
709 #[derive(Clone)]
710 pub struct AddressIsZero;
711 #[allow(
712 non_camel_case_types,
713 non_snake_case,
714 clippy::pub_underscore_fields,
715 clippy::style
716 )]
717 const _: () = {
718 use alloy::sol_types as alloy_sol_types;
719 #[doc(hidden)]
720 type UnderlyingSolTuple<'a> = ();
721 #[doc(hidden)]
722 type UnderlyingRustTuple<'a> = ();
723 #[cfg(test)]
724 #[allow(dead_code, unreachable_patterns)]
725 fn _type_assertion(
726 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
727 ) {
728 match _t {
729 alloy_sol_types::private::AssertTypeEq::<
730 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
731 >(_) => {}
732 }
733 }
734 #[automatically_derived]
735 #[doc(hidden)]
736 impl ::core::convert::From<AddressIsZero> for UnderlyingRustTuple<'_> {
737 fn from(value: AddressIsZero) -> Self {
738 ()
739 }
740 }
741 #[automatically_derived]
742 #[doc(hidden)]
743 impl ::core::convert::From<UnderlyingRustTuple<'_>> for AddressIsZero {
744 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
745 Self
746 }
747 }
748 #[automatically_derived]
749 impl alloy_sol_types::SolError for AddressIsZero {
750 type Parameters<'a> = UnderlyingSolTuple<'a>;
751 type Token<'a> = <Self::Parameters<
752 'a,
753 > as alloy_sol_types::SolType>::Token<'a>;
754 const SIGNATURE: &'static str = "AddressIsZero()";
755 const SELECTOR: [u8; 4] = [134u8, 121u8, 21u8, 171u8];
756 #[inline]
757 fn new<'a>(
758 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
759 ) -> Self {
760 tuple.into()
761 }
762 #[inline]
763 fn tokenize(&self) -> Self::Token<'_> {
764 ()
765 }
766 #[inline]
767 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
768 <Self::Parameters<
769 '_,
770 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
771 .map(Self::new)
772 }
773 }
774 };
775 #[derive(serde::Serialize, serde::Deserialize)]
776 #[derive(Default, Debug, PartialEq, Eq, Hash)]
777 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
782 #[derive(Clone)]
783 pub struct ArrayTooLong;
784 #[allow(
785 non_camel_case_types,
786 non_snake_case,
787 clippy::pub_underscore_fields,
788 clippy::style
789 )]
790 const _: () = {
791 use alloy::sol_types as alloy_sol_types;
792 #[doc(hidden)]
793 type UnderlyingSolTuple<'a> = ();
794 #[doc(hidden)]
795 type UnderlyingRustTuple<'a> = ();
796 #[cfg(test)]
797 #[allow(dead_code, unreachable_patterns)]
798 fn _type_assertion(
799 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
800 ) {
801 match _t {
802 alloy_sol_types::private::AssertTypeEq::<
803 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
804 >(_) => {}
805 }
806 }
807 #[automatically_derived]
808 #[doc(hidden)]
809 impl ::core::convert::From<ArrayTooLong> for UnderlyingRustTuple<'_> {
810 fn from(value: ArrayTooLong) -> Self {
811 ()
812 }
813 }
814 #[automatically_derived]
815 #[doc(hidden)]
816 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ArrayTooLong {
817 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
818 Self
819 }
820 }
821 #[automatically_derived]
822 impl alloy_sol_types::SolError for ArrayTooLong {
823 type Parameters<'a> = UnderlyingSolTuple<'a>;
824 type Token<'a> = <Self::Parameters<
825 'a,
826 > as alloy_sol_types::SolType>::Token<'a>;
827 const SIGNATURE: &'static str = "ArrayTooLong()";
828 const SELECTOR: [u8; 4] = [189u8, 38u8, 204u8, 56u8];
829 #[inline]
830 fn new<'a>(
831 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
832 ) -> Self {
833 tuple.into()
834 }
835 #[inline]
836 fn tokenize(&self) -> Self::Token<'_> {
837 ()
838 }
839 #[inline]
840 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
841 <Self::Parameters<
842 '_,
843 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
844 .map(Self::new)
845 }
846 }
847 };
848 #[derive(serde::Serialize, serde::Deserialize)]
849 #[derive(Default, Debug, PartialEq, Eq, Hash)]
850 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
855 #[derive(Clone)]
856 pub struct ArraysDifferentLength;
857 #[allow(
858 non_camel_case_types,
859 non_snake_case,
860 clippy::pub_underscore_fields,
861 clippy::style
862 )]
863 const _: () = {
864 use alloy::sol_types as alloy_sol_types;
865 #[doc(hidden)]
866 type UnderlyingSolTuple<'a> = ();
867 #[doc(hidden)]
868 type UnderlyingRustTuple<'a> = ();
869 #[cfg(test)]
870 #[allow(dead_code, unreachable_patterns)]
871 fn _type_assertion(
872 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
873 ) {
874 match _t {
875 alloy_sol_types::private::AssertTypeEq::<
876 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
877 >(_) => {}
878 }
879 }
880 #[automatically_derived]
881 #[doc(hidden)]
882 impl ::core::convert::From<ArraysDifferentLength> for UnderlyingRustTuple<'_> {
883 fn from(value: ArraysDifferentLength) -> Self {
884 ()
885 }
886 }
887 #[automatically_derived]
888 #[doc(hidden)]
889 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ArraysDifferentLength {
890 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
891 Self
892 }
893 }
894 #[automatically_derived]
895 impl alloy_sol_types::SolError for ArraysDifferentLength {
896 type Parameters<'a> = UnderlyingSolTuple<'a>;
897 type Token<'a> = <Self::Parameters<
898 'a,
899 > as alloy_sol_types::SolType>::Token<'a>;
900 const SIGNATURE: &'static str = "ArraysDifferentLength()";
901 const SELECTOR: [u8; 4] = [116u8, 244u8, 213u8, 55u8];
902 #[inline]
903 fn new<'a>(
904 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
905 ) -> Self {
906 tuple.into()
907 }
908 #[inline]
909 fn tokenize(&self) -> Self::Token<'_> {
910 ()
911 }
912 #[inline]
913 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
914 <Self::Parameters<
915 '_,
916 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
917 .map(Self::new)
918 }
919 }
920 };
921 #[derive(serde::Serialize, serde::Deserialize)]
922 #[derive(Default, Debug, PartialEq, Eq, Hash)]
923 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
928 #[derive(Clone)]
929 pub struct CalldataOutOfBounds;
930 #[allow(
931 non_camel_case_types,
932 non_snake_case,
933 clippy::pub_underscore_fields,
934 clippy::style
935 )]
936 const _: () = {
937 use alloy::sol_types as alloy_sol_types;
938 #[doc(hidden)]
939 type UnderlyingSolTuple<'a> = ();
940 #[doc(hidden)]
941 type UnderlyingRustTuple<'a> = ();
942 #[cfg(test)]
943 #[allow(dead_code, unreachable_patterns)]
944 fn _type_assertion(
945 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
946 ) {
947 match _t {
948 alloy_sol_types::private::AssertTypeEq::<
949 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
950 >(_) => {}
951 }
952 }
953 #[automatically_derived]
954 #[doc(hidden)]
955 impl ::core::convert::From<CalldataOutOfBounds> for UnderlyingRustTuple<'_> {
956 fn from(value: CalldataOutOfBounds) -> Self {
957 ()
958 }
959 }
960 #[automatically_derived]
961 #[doc(hidden)]
962 impl ::core::convert::From<UnderlyingRustTuple<'_>> for CalldataOutOfBounds {
963 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
964 Self
965 }
966 }
967 #[automatically_derived]
968 impl alloy_sol_types::SolError for CalldataOutOfBounds {
969 type Parameters<'a> = UnderlyingSolTuple<'a>;
970 type Token<'a> = <Self::Parameters<
971 'a,
972 > as alloy_sol_types::SolType>::Token<'a>;
973 const SIGNATURE: &'static str = "CalldataOutOfBounds()";
974 const SELECTOR: [u8; 4] = [116u8, 38u8, 56u8, 180u8];
975 #[inline]
976 fn new<'a>(
977 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
978 ) -> Self {
979 tuple.into()
980 }
981 #[inline]
982 fn tokenize(&self) -> Self::Token<'_> {
983 ()
984 }
985 #[inline]
986 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
987 <Self::Parameters<
988 '_,
989 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
990 .map(Self::new)
991 }
992 }
993 };
994 #[derive(serde::Serialize, serde::Deserialize)]
995 #[derive(Default, Debug, PartialEq, Eq, Hash)]
996 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1001 #[derive(Clone)]
1002 pub struct DefaultPermissionRejected;
1003 #[allow(
1004 non_camel_case_types,
1005 non_snake_case,
1006 clippy::pub_underscore_fields,
1007 clippy::style
1008 )]
1009 const _: () = {
1010 use alloy::sol_types as alloy_sol_types;
1011 #[doc(hidden)]
1012 type UnderlyingSolTuple<'a> = ();
1013 #[doc(hidden)]
1014 type UnderlyingRustTuple<'a> = ();
1015 #[cfg(test)]
1016 #[allow(dead_code, unreachable_patterns)]
1017 fn _type_assertion(
1018 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1019 ) {
1020 match _t {
1021 alloy_sol_types::private::AssertTypeEq::<
1022 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1023 >(_) => {}
1024 }
1025 }
1026 #[automatically_derived]
1027 #[doc(hidden)]
1028 impl ::core::convert::From<DefaultPermissionRejected>
1029 for UnderlyingRustTuple<'_> {
1030 fn from(value: DefaultPermissionRejected) -> Self {
1031 ()
1032 }
1033 }
1034 #[automatically_derived]
1035 #[doc(hidden)]
1036 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1037 for DefaultPermissionRejected {
1038 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1039 Self
1040 }
1041 }
1042 #[automatically_derived]
1043 impl alloy_sol_types::SolError for DefaultPermissionRejected {
1044 type Parameters<'a> = UnderlyingSolTuple<'a>;
1045 type Token<'a> = <Self::Parameters<
1046 'a,
1047 > as alloy_sol_types::SolType>::Token<'a>;
1048 const SIGNATURE: &'static str = "DefaultPermissionRejected()";
1049 const SELECTOR: [u8; 4] = [88u8, 114u8, 48u8, 55u8];
1050 #[inline]
1051 fn new<'a>(
1052 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1053 ) -> Self {
1054 tuple.into()
1055 }
1056 #[inline]
1057 fn tokenize(&self) -> Self::Token<'_> {
1058 ()
1059 }
1060 #[inline]
1061 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1062 <Self::Parameters<
1063 '_,
1064 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1065 .map(Self::new)
1066 }
1067 }
1068 };
1069 #[derive(serde::Serialize, serde::Deserialize)]
1070 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1071 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1076 #[derive(Clone)]
1077 pub struct DelegateCallNotAllowed;
1078 #[allow(
1079 non_camel_case_types,
1080 non_snake_case,
1081 clippy::pub_underscore_fields,
1082 clippy::style
1083 )]
1084 const _: () = {
1085 use alloy::sol_types as alloy_sol_types;
1086 #[doc(hidden)]
1087 type UnderlyingSolTuple<'a> = ();
1088 #[doc(hidden)]
1089 type UnderlyingRustTuple<'a> = ();
1090 #[cfg(test)]
1091 #[allow(dead_code, unreachable_patterns)]
1092 fn _type_assertion(
1093 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1094 ) {
1095 match _t {
1096 alloy_sol_types::private::AssertTypeEq::<
1097 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1098 >(_) => {}
1099 }
1100 }
1101 #[automatically_derived]
1102 #[doc(hidden)]
1103 impl ::core::convert::From<DelegateCallNotAllowed> for UnderlyingRustTuple<'_> {
1104 fn from(value: DelegateCallNotAllowed) -> Self {
1105 ()
1106 }
1107 }
1108 #[automatically_derived]
1109 #[doc(hidden)]
1110 impl ::core::convert::From<UnderlyingRustTuple<'_>> for DelegateCallNotAllowed {
1111 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1112 Self
1113 }
1114 }
1115 #[automatically_derived]
1116 impl alloy_sol_types::SolError for DelegateCallNotAllowed {
1117 type Parameters<'a> = UnderlyingSolTuple<'a>;
1118 type Token<'a> = <Self::Parameters<
1119 'a,
1120 > as alloy_sol_types::SolType>::Token<'a>;
1121 const SIGNATURE: &'static str = "DelegateCallNotAllowed()";
1122 const SELECTOR: [u8; 4] = [13u8, 137u8, 67u8, 142u8];
1123 #[inline]
1124 fn new<'a>(
1125 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1126 ) -> Self {
1127 tuple.into()
1128 }
1129 #[inline]
1130 fn tokenize(&self) -> Self::Token<'_> {
1131 ()
1132 }
1133 #[inline]
1134 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1135 <Self::Parameters<
1136 '_,
1137 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1138 .map(Self::new)
1139 }
1140 }
1141 };
1142 #[derive(serde::Serialize, serde::Deserialize)]
1143 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1144 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1149 #[derive(Clone)]
1150 pub struct FunctionSignatureTooShort;
1151 #[allow(
1152 non_camel_case_types,
1153 non_snake_case,
1154 clippy::pub_underscore_fields,
1155 clippy::style
1156 )]
1157 const _: () = {
1158 use alloy::sol_types as alloy_sol_types;
1159 #[doc(hidden)]
1160 type UnderlyingSolTuple<'a> = ();
1161 #[doc(hidden)]
1162 type UnderlyingRustTuple<'a> = ();
1163 #[cfg(test)]
1164 #[allow(dead_code, unreachable_patterns)]
1165 fn _type_assertion(
1166 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1167 ) {
1168 match _t {
1169 alloy_sol_types::private::AssertTypeEq::<
1170 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1171 >(_) => {}
1172 }
1173 }
1174 #[automatically_derived]
1175 #[doc(hidden)]
1176 impl ::core::convert::From<FunctionSignatureTooShort>
1177 for UnderlyingRustTuple<'_> {
1178 fn from(value: FunctionSignatureTooShort) -> Self {
1179 ()
1180 }
1181 }
1182 #[automatically_derived]
1183 #[doc(hidden)]
1184 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1185 for FunctionSignatureTooShort {
1186 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1187 Self
1188 }
1189 }
1190 #[automatically_derived]
1191 impl alloy_sol_types::SolError for FunctionSignatureTooShort {
1192 type Parameters<'a> = UnderlyingSolTuple<'a>;
1193 type Token<'a> = <Self::Parameters<
1194 'a,
1195 > as alloy_sol_types::SolType>::Token<'a>;
1196 const SIGNATURE: &'static str = "FunctionSignatureTooShort()";
1197 const SELECTOR: [u8; 4] = [70u8, 132u8, 193u8, 34u8];
1198 #[inline]
1199 fn new<'a>(
1200 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1201 ) -> Self {
1202 tuple.into()
1203 }
1204 #[inline]
1205 fn tokenize(&self) -> Self::Token<'_> {
1206 ()
1207 }
1208 #[inline]
1209 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1210 <Self::Parameters<
1211 '_,
1212 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1213 .map(Self::new)
1214 }
1215 }
1216 };
1217 #[derive(serde::Serialize, serde::Deserialize)]
1218 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1219 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1224 #[derive(Clone)]
1225 pub struct GranularPermissionRejected;
1226 #[allow(
1227 non_camel_case_types,
1228 non_snake_case,
1229 clippy::pub_underscore_fields,
1230 clippy::style
1231 )]
1232 const _: () = {
1233 use alloy::sol_types as alloy_sol_types;
1234 #[doc(hidden)]
1235 type UnderlyingSolTuple<'a> = ();
1236 #[doc(hidden)]
1237 type UnderlyingRustTuple<'a> = ();
1238 #[cfg(test)]
1239 #[allow(dead_code, unreachable_patterns)]
1240 fn _type_assertion(
1241 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1242 ) {
1243 match _t {
1244 alloy_sol_types::private::AssertTypeEq::<
1245 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1246 >(_) => {}
1247 }
1248 }
1249 #[automatically_derived]
1250 #[doc(hidden)]
1251 impl ::core::convert::From<GranularPermissionRejected>
1252 for UnderlyingRustTuple<'_> {
1253 fn from(value: GranularPermissionRejected) -> Self {
1254 ()
1255 }
1256 }
1257 #[automatically_derived]
1258 #[doc(hidden)]
1259 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1260 for GranularPermissionRejected {
1261 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1262 Self
1263 }
1264 }
1265 #[automatically_derived]
1266 impl alloy_sol_types::SolError for GranularPermissionRejected {
1267 type Parameters<'a> = UnderlyingSolTuple<'a>;
1268 type Token<'a> = <Self::Parameters<
1269 'a,
1270 > as alloy_sol_types::SolType>::Token<'a>;
1271 const SIGNATURE: &'static str = "GranularPermissionRejected()";
1272 const SELECTOR: [u8; 4] = [134u8, 77u8, 209u8, 231u8];
1273 #[inline]
1274 fn new<'a>(
1275 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1276 ) -> Self {
1277 tuple.into()
1278 }
1279 #[inline]
1280 fn tokenize(&self) -> Self::Token<'_> {
1281 ()
1282 }
1283 #[inline]
1284 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1285 <Self::Parameters<
1286 '_,
1287 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1288 .map(Self::new)
1289 }
1290 }
1291 };
1292 #[derive(serde::Serialize, serde::Deserialize)]
1293 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1294 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1299 #[derive(Clone)]
1300 pub struct NoMembership;
1301 #[allow(
1302 non_camel_case_types,
1303 non_snake_case,
1304 clippy::pub_underscore_fields,
1305 clippy::style
1306 )]
1307 const _: () = {
1308 use alloy::sol_types as alloy_sol_types;
1309 #[doc(hidden)]
1310 type UnderlyingSolTuple<'a> = ();
1311 #[doc(hidden)]
1312 type UnderlyingRustTuple<'a> = ();
1313 #[cfg(test)]
1314 #[allow(dead_code, unreachable_patterns)]
1315 fn _type_assertion(
1316 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1317 ) {
1318 match _t {
1319 alloy_sol_types::private::AssertTypeEq::<
1320 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1321 >(_) => {}
1322 }
1323 }
1324 #[automatically_derived]
1325 #[doc(hidden)]
1326 impl ::core::convert::From<NoMembership> for UnderlyingRustTuple<'_> {
1327 fn from(value: NoMembership) -> Self {
1328 ()
1329 }
1330 }
1331 #[automatically_derived]
1332 #[doc(hidden)]
1333 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NoMembership {
1334 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1335 Self
1336 }
1337 }
1338 #[automatically_derived]
1339 impl alloy_sol_types::SolError for NoMembership {
1340 type Parameters<'a> = UnderlyingSolTuple<'a>;
1341 type Token<'a> = <Self::Parameters<
1342 'a,
1343 > as alloy_sol_types::SolType>::Token<'a>;
1344 const SIGNATURE: &'static str = "NoMembership()";
1345 const SELECTOR: [u8; 4] = [253u8, 142u8, 159u8, 40u8];
1346 #[inline]
1347 fn new<'a>(
1348 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1349 ) -> Self {
1350 tuple.into()
1351 }
1352 #[inline]
1353 fn tokenize(&self) -> Self::Token<'_> {
1354 ()
1355 }
1356 #[inline]
1357 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1358 <Self::Parameters<
1359 '_,
1360 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1361 .map(Self::new)
1362 }
1363 }
1364 };
1365 #[derive(serde::Serialize, serde::Deserialize)]
1366 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1367 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1372 #[derive(Clone)]
1373 pub struct NodePermissionRejected;
1374 #[allow(
1375 non_camel_case_types,
1376 non_snake_case,
1377 clippy::pub_underscore_fields,
1378 clippy::style
1379 )]
1380 const _: () = {
1381 use alloy::sol_types as alloy_sol_types;
1382 #[doc(hidden)]
1383 type UnderlyingSolTuple<'a> = ();
1384 #[doc(hidden)]
1385 type UnderlyingRustTuple<'a> = ();
1386 #[cfg(test)]
1387 #[allow(dead_code, unreachable_patterns)]
1388 fn _type_assertion(
1389 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1390 ) {
1391 match _t {
1392 alloy_sol_types::private::AssertTypeEq::<
1393 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1394 >(_) => {}
1395 }
1396 }
1397 #[automatically_derived]
1398 #[doc(hidden)]
1399 impl ::core::convert::From<NodePermissionRejected> for UnderlyingRustTuple<'_> {
1400 fn from(value: NodePermissionRejected) -> Self {
1401 ()
1402 }
1403 }
1404 #[automatically_derived]
1405 #[doc(hidden)]
1406 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NodePermissionRejected {
1407 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1408 Self
1409 }
1410 }
1411 #[automatically_derived]
1412 impl alloy_sol_types::SolError for NodePermissionRejected {
1413 type Parameters<'a> = UnderlyingSolTuple<'a>;
1414 type Token<'a> = <Self::Parameters<
1415 'a,
1416 > as alloy_sol_types::SolType>::Token<'a>;
1417 const SIGNATURE: &'static str = "NodePermissionRejected()";
1418 const SELECTOR: [u8; 4] = [110u8, 176u8, 49u8, 95u8];
1419 #[inline]
1420 fn new<'a>(
1421 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1422 ) -> Self {
1423 tuple.into()
1424 }
1425 #[inline]
1426 fn tokenize(&self) -> Self::Token<'_> {
1427 ()
1428 }
1429 #[inline]
1430 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1431 <Self::Parameters<
1432 '_,
1433 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1434 .map(Self::new)
1435 }
1436 }
1437 };
1438 #[derive(serde::Serialize, serde::Deserialize)]
1439 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1440 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1445 #[derive(Clone)]
1446 pub struct ParameterNotAllowed;
1447 #[allow(
1448 non_camel_case_types,
1449 non_snake_case,
1450 clippy::pub_underscore_fields,
1451 clippy::style
1452 )]
1453 const _: () = {
1454 use alloy::sol_types as alloy_sol_types;
1455 #[doc(hidden)]
1456 type UnderlyingSolTuple<'a> = ();
1457 #[doc(hidden)]
1458 type UnderlyingRustTuple<'a> = ();
1459 #[cfg(test)]
1460 #[allow(dead_code, unreachable_patterns)]
1461 fn _type_assertion(
1462 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1463 ) {
1464 match _t {
1465 alloy_sol_types::private::AssertTypeEq::<
1466 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1467 >(_) => {}
1468 }
1469 }
1470 #[automatically_derived]
1471 #[doc(hidden)]
1472 impl ::core::convert::From<ParameterNotAllowed> for UnderlyingRustTuple<'_> {
1473 fn from(value: ParameterNotAllowed) -> Self {
1474 ()
1475 }
1476 }
1477 #[automatically_derived]
1478 #[doc(hidden)]
1479 impl ::core::convert::From<UnderlyingRustTuple<'_>> for ParameterNotAllowed {
1480 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1481 Self
1482 }
1483 }
1484 #[automatically_derived]
1485 impl alloy_sol_types::SolError for ParameterNotAllowed {
1486 type Parameters<'a> = UnderlyingSolTuple<'a>;
1487 type Token<'a> = <Self::Parameters<
1488 'a,
1489 > as alloy_sol_types::SolType>::Token<'a>;
1490 const SIGNATURE: &'static str = "ParameterNotAllowed()";
1491 const SELECTOR: [u8; 4] = [49u8, 233u8, 130u8, 70u8];
1492 #[inline]
1493 fn new<'a>(
1494 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1495 ) -> Self {
1496 tuple.into()
1497 }
1498 #[inline]
1499 fn tokenize(&self) -> Self::Token<'_> {
1500 ()
1501 }
1502 #[inline]
1503 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1504 <Self::Parameters<
1505 '_,
1506 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1507 .map(Self::new)
1508 }
1509 }
1510 };
1511 #[derive(serde::Serialize, serde::Deserialize)]
1512 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1513 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1518 #[derive(Clone)]
1519 pub struct PermissionNotConfigured;
1520 #[allow(
1521 non_camel_case_types,
1522 non_snake_case,
1523 clippy::pub_underscore_fields,
1524 clippy::style
1525 )]
1526 const _: () = {
1527 use alloy::sol_types as alloy_sol_types;
1528 #[doc(hidden)]
1529 type UnderlyingSolTuple<'a> = ();
1530 #[doc(hidden)]
1531 type UnderlyingRustTuple<'a> = ();
1532 #[cfg(test)]
1533 #[allow(dead_code, unreachable_patterns)]
1534 fn _type_assertion(
1535 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1536 ) {
1537 match _t {
1538 alloy_sol_types::private::AssertTypeEq::<
1539 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1540 >(_) => {}
1541 }
1542 }
1543 #[automatically_derived]
1544 #[doc(hidden)]
1545 impl ::core::convert::From<PermissionNotConfigured> for UnderlyingRustTuple<'_> {
1546 fn from(value: PermissionNotConfigured) -> Self {
1547 ()
1548 }
1549 }
1550 #[automatically_derived]
1551 #[doc(hidden)]
1552 impl ::core::convert::From<UnderlyingRustTuple<'_>> for PermissionNotConfigured {
1553 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1554 Self
1555 }
1556 }
1557 #[automatically_derived]
1558 impl alloy_sol_types::SolError for PermissionNotConfigured {
1559 type Parameters<'a> = UnderlyingSolTuple<'a>;
1560 type Token<'a> = <Self::Parameters<
1561 'a,
1562 > as alloy_sol_types::SolType>::Token<'a>;
1563 const SIGNATURE: &'static str = "PermissionNotConfigured()";
1564 const SELECTOR: [u8; 4] = [70u8, 173u8, 69u8, 136u8];
1565 #[inline]
1566 fn new<'a>(
1567 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1568 ) -> Self {
1569 tuple.into()
1570 }
1571 #[inline]
1572 fn tokenize(&self) -> Self::Token<'_> {
1573 ()
1574 }
1575 #[inline]
1576 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1577 <Self::Parameters<
1578 '_,
1579 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1580 .map(Self::new)
1581 }
1582 }
1583 };
1584 #[derive(serde::Serialize, serde::Deserialize)]
1585 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1586 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1591 #[derive(Clone)]
1592 pub struct SendNotAllowed;
1593 #[allow(
1594 non_camel_case_types,
1595 non_snake_case,
1596 clippy::pub_underscore_fields,
1597 clippy::style
1598 )]
1599 const _: () = {
1600 use alloy::sol_types as alloy_sol_types;
1601 #[doc(hidden)]
1602 type UnderlyingSolTuple<'a> = ();
1603 #[doc(hidden)]
1604 type UnderlyingRustTuple<'a> = ();
1605 #[cfg(test)]
1606 #[allow(dead_code, unreachable_patterns)]
1607 fn _type_assertion(
1608 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1609 ) {
1610 match _t {
1611 alloy_sol_types::private::AssertTypeEq::<
1612 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1613 >(_) => {}
1614 }
1615 }
1616 #[automatically_derived]
1617 #[doc(hidden)]
1618 impl ::core::convert::From<SendNotAllowed> for UnderlyingRustTuple<'_> {
1619 fn from(value: SendNotAllowed) -> Self {
1620 ()
1621 }
1622 }
1623 #[automatically_derived]
1624 #[doc(hidden)]
1625 impl ::core::convert::From<UnderlyingRustTuple<'_>> for SendNotAllowed {
1626 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1627 Self
1628 }
1629 }
1630 #[automatically_derived]
1631 impl alloy_sol_types::SolError for SendNotAllowed {
1632 type Parameters<'a> = UnderlyingSolTuple<'a>;
1633 type Token<'a> = <Self::Parameters<
1634 'a,
1635 > as alloy_sol_types::SolType>::Token<'a>;
1636 const SIGNATURE: &'static str = "SendNotAllowed()";
1637 const SELECTOR: [u8; 4] = [9u8, 233u8, 205u8, 73u8];
1638 #[inline]
1639 fn new<'a>(
1640 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1641 ) -> Self {
1642 tuple.into()
1643 }
1644 #[inline]
1645 fn tokenize(&self) -> Self::Token<'_> {
1646 ()
1647 }
1648 #[inline]
1649 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1650 <Self::Parameters<
1651 '_,
1652 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1653 .map(Self::new)
1654 }
1655 }
1656 };
1657 #[derive(serde::Serialize, serde::Deserialize)]
1658 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1659 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1664 #[derive(Clone)]
1665 pub struct TargetAddressNotAllowed;
1666 #[allow(
1667 non_camel_case_types,
1668 non_snake_case,
1669 clippy::pub_underscore_fields,
1670 clippy::style
1671 )]
1672 const _: () = {
1673 use alloy::sol_types as alloy_sol_types;
1674 #[doc(hidden)]
1675 type UnderlyingSolTuple<'a> = ();
1676 #[doc(hidden)]
1677 type UnderlyingRustTuple<'a> = ();
1678 #[cfg(test)]
1679 #[allow(dead_code, unreachable_patterns)]
1680 fn _type_assertion(
1681 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1682 ) {
1683 match _t {
1684 alloy_sol_types::private::AssertTypeEq::<
1685 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1686 >(_) => {}
1687 }
1688 }
1689 #[automatically_derived]
1690 #[doc(hidden)]
1691 impl ::core::convert::From<TargetAddressNotAllowed> for UnderlyingRustTuple<'_> {
1692 fn from(value: TargetAddressNotAllowed) -> Self {
1693 ()
1694 }
1695 }
1696 #[automatically_derived]
1697 #[doc(hidden)]
1698 impl ::core::convert::From<UnderlyingRustTuple<'_>> for TargetAddressNotAllowed {
1699 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1700 Self
1701 }
1702 }
1703 #[automatically_derived]
1704 impl alloy_sol_types::SolError for TargetAddressNotAllowed {
1705 type Parameters<'a> = UnderlyingSolTuple<'a>;
1706 type Token<'a> = <Self::Parameters<
1707 'a,
1708 > as alloy_sol_types::SolType>::Token<'a>;
1709 const SIGNATURE: &'static str = "TargetAddressNotAllowed()";
1710 const SELECTOR: [u8; 4] = [239u8, 52u8, 64u8, 172u8];
1711 #[inline]
1712 fn new<'a>(
1713 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1714 ) -> Self {
1715 tuple.into()
1716 }
1717 #[inline]
1718 fn tokenize(&self) -> Self::Token<'_> {
1719 ()
1720 }
1721 #[inline]
1722 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1723 <Self::Parameters<
1724 '_,
1725 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1726 .map(Self::new)
1727 }
1728 }
1729 };
1730 #[derive(serde::Serialize, serde::Deserialize)]
1731 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1732 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1737 #[derive(Clone)]
1738 pub struct TargetIsNotScoped;
1739 #[allow(
1740 non_camel_case_types,
1741 non_snake_case,
1742 clippy::pub_underscore_fields,
1743 clippy::style
1744 )]
1745 const _: () = {
1746 use alloy::sol_types as alloy_sol_types;
1747 #[doc(hidden)]
1748 type UnderlyingSolTuple<'a> = ();
1749 #[doc(hidden)]
1750 type UnderlyingRustTuple<'a> = ();
1751 #[cfg(test)]
1752 #[allow(dead_code, unreachable_patterns)]
1753 fn _type_assertion(
1754 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1755 ) {
1756 match _t {
1757 alloy_sol_types::private::AssertTypeEq::<
1758 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1759 >(_) => {}
1760 }
1761 }
1762 #[automatically_derived]
1763 #[doc(hidden)]
1764 impl ::core::convert::From<TargetIsNotScoped> for UnderlyingRustTuple<'_> {
1765 fn from(value: TargetIsNotScoped) -> Self {
1766 ()
1767 }
1768 }
1769 #[automatically_derived]
1770 #[doc(hidden)]
1771 impl ::core::convert::From<UnderlyingRustTuple<'_>> for TargetIsNotScoped {
1772 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1773 Self
1774 }
1775 }
1776 #[automatically_derived]
1777 impl alloy_sol_types::SolError for TargetIsNotScoped {
1778 type Parameters<'a> = UnderlyingSolTuple<'a>;
1779 type Token<'a> = <Self::Parameters<
1780 'a,
1781 > as alloy_sol_types::SolType>::Token<'a>;
1782 const SIGNATURE: &'static str = "TargetIsNotScoped()";
1783 const SELECTOR: [u8; 4] = [74u8, 137u8, 3u8, 33u8];
1784 #[inline]
1785 fn new<'a>(
1786 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1787 ) -> Self {
1788 tuple.into()
1789 }
1790 #[inline]
1791 fn tokenize(&self) -> Self::Token<'_> {
1792 ()
1793 }
1794 #[inline]
1795 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1796 <Self::Parameters<
1797 '_,
1798 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1799 .map(Self::new)
1800 }
1801 }
1802 };
1803 #[derive(serde::Serialize, serde::Deserialize)]
1804 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1805 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1810 #[derive(Clone)]
1811 pub struct TargetIsScoped;
1812 #[allow(
1813 non_camel_case_types,
1814 non_snake_case,
1815 clippy::pub_underscore_fields,
1816 clippy::style
1817 )]
1818 const _: () = {
1819 use alloy::sol_types as alloy_sol_types;
1820 #[doc(hidden)]
1821 type UnderlyingSolTuple<'a> = ();
1822 #[doc(hidden)]
1823 type UnderlyingRustTuple<'a> = ();
1824 #[cfg(test)]
1825 #[allow(dead_code, unreachable_patterns)]
1826 fn _type_assertion(
1827 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1828 ) {
1829 match _t {
1830 alloy_sol_types::private::AssertTypeEq::<
1831 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1832 >(_) => {}
1833 }
1834 }
1835 #[automatically_derived]
1836 #[doc(hidden)]
1837 impl ::core::convert::From<TargetIsScoped> for UnderlyingRustTuple<'_> {
1838 fn from(value: TargetIsScoped) -> Self {
1839 ()
1840 }
1841 }
1842 #[automatically_derived]
1843 #[doc(hidden)]
1844 impl ::core::convert::From<UnderlyingRustTuple<'_>> for TargetIsScoped {
1845 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1846 Self
1847 }
1848 }
1849 #[automatically_derived]
1850 impl alloy_sol_types::SolError for TargetIsScoped {
1851 type Parameters<'a> = UnderlyingSolTuple<'a>;
1852 type Token<'a> = <Self::Parameters<
1853 'a,
1854 > as alloy_sol_types::SolType>::Token<'a>;
1855 const SIGNATURE: &'static str = "TargetIsScoped()";
1856 const SELECTOR: [u8; 4] = [232u8, 192u8, 125u8, 42u8];
1857 #[inline]
1858 fn new<'a>(
1859 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1860 ) -> Self {
1861 tuple.into()
1862 }
1863 #[inline]
1864 fn tokenize(&self) -> Self::Token<'_> {
1865 ()
1866 }
1867 #[inline]
1868 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1869 <Self::Parameters<
1870 '_,
1871 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1872 .map(Self::new)
1873 }
1874 }
1875 };
1876 #[derive(serde::Serialize, serde::Deserialize)]
1877 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1878 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1883 #[derive(Clone)]
1884 pub struct UnacceptableMultiSendOffset;
1885 #[allow(
1886 non_camel_case_types,
1887 non_snake_case,
1888 clippy::pub_underscore_fields,
1889 clippy::style
1890 )]
1891 const _: () = {
1892 use alloy::sol_types as alloy_sol_types;
1893 #[doc(hidden)]
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<UnacceptableMultiSendOffset>
1911 for UnderlyingRustTuple<'_> {
1912 fn from(value: UnacceptableMultiSendOffset) -> Self {
1913 ()
1914 }
1915 }
1916 #[automatically_derived]
1917 #[doc(hidden)]
1918 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1919 for UnacceptableMultiSendOffset {
1920 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1921 Self
1922 }
1923 }
1924 #[automatically_derived]
1925 impl alloy_sol_types::SolError for UnacceptableMultiSendOffset {
1926 type Parameters<'a> = UnderlyingSolTuple<'a>;
1927 type Token<'a> = <Self::Parameters<
1928 'a,
1929 > as alloy_sol_types::SolType>::Token<'a>;
1930 const SIGNATURE: &'static str = "UnacceptableMultiSendOffset()";
1931 const SELECTOR: [u8; 4] = [126u8, 209u8, 17u8, 55u8];
1932 #[inline]
1933 fn new<'a>(
1934 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1935 ) -> Self {
1936 tuple.into()
1937 }
1938 #[inline]
1939 fn tokenize(&self) -> Self::Token<'_> {
1940 ()
1941 }
1942 #[inline]
1943 fn abi_decode_raw_validate(data: &[u8]) -> alloy_sol_types::Result<Self> {
1944 <Self::Parameters<
1945 '_,
1946 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
1947 .map(Self::new)
1948 }
1949 }
1950 };
1951 #[derive(serde::Serialize, serde::Deserialize)]
1952 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1953 #[allow(
1958 non_camel_case_types,
1959 non_snake_case,
1960 clippy::pub_underscore_fields,
1961 clippy::style
1962 )]
1963 #[derive(Clone)]
1964 pub struct RevokedTarget {
1965 #[allow(missing_docs)]
1966 pub targetAddress: alloy::sol_types::private::Address,
1967 }
1968 #[allow(
1969 non_camel_case_types,
1970 non_snake_case,
1971 clippy::pub_underscore_fields,
1972 clippy::style
1973 )]
1974 const _: () = {
1975 use alloy::sol_types as alloy_sol_types;
1976 #[automatically_derived]
1977 impl alloy_sol_types::SolEvent for RevokedTarget {
1978 type DataTuple<'a> = ();
1979 type DataToken<'a> = <Self::DataTuple<
1980 'a,
1981 > as alloy_sol_types::SolType>::Token<'a>;
1982 type TopicList = (
1983 alloy_sol_types::sol_data::FixedBytes<32>,
1984 alloy::sol_types::sol_data::Address,
1985 );
1986 const SIGNATURE: &'static str = "RevokedTarget(address)";
1987 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
1988 13u8, 252u8, 225u8, 234u8, 75u8, 161u8, 238u8, 186u8, 137u8, 31u8, 251u8,
1989 42u8, 6u8, 103u8, 144u8, 251u8, 194u8, 147u8, 169u8, 229u8, 23u8, 254u8,
1990 97u8, 212u8, 157u8, 21u8, 106u8, 48u8, 22u8, 95u8, 147u8, 243u8,
1991 ]);
1992 const ANONYMOUS: bool = false;
1993 #[allow(unused_variables)]
1994 #[inline]
1995 fn new(
1996 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
1997 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
1998 ) -> Self {
1999 Self { targetAddress: topics.1 }
2000 }
2001 #[inline]
2002 fn check_signature(
2003 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2004 ) -> alloy_sol_types::Result<()> {
2005 if topics.0 != Self::SIGNATURE_HASH {
2006 return Err(
2007 alloy_sol_types::Error::invalid_event_signature_hash(
2008 Self::SIGNATURE,
2009 topics.0,
2010 Self::SIGNATURE_HASH,
2011 ),
2012 );
2013 }
2014 Ok(())
2015 }
2016 #[inline]
2017 fn tokenize_body(&self) -> Self::DataToken<'_> {
2018 ()
2019 }
2020 #[inline]
2021 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2022 (Self::SIGNATURE_HASH.into(), self.targetAddress.clone())
2023 }
2024 #[inline]
2025 fn encode_topics_raw(
2026 &self,
2027 out: &mut [alloy_sol_types::abi::token::WordToken],
2028 ) -> alloy_sol_types::Result<()> {
2029 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2030 return Err(alloy_sol_types::Error::Overrun);
2031 }
2032 out[0usize] = alloy_sol_types::abi::token::WordToken(
2033 Self::SIGNATURE_HASH,
2034 );
2035 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2036 &self.targetAddress,
2037 );
2038 Ok(())
2039 }
2040 }
2041 #[automatically_derived]
2042 impl alloy_sol_types::private::IntoLogData for RevokedTarget {
2043 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2044 From::from(self)
2045 }
2046 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2047 From::from(&self)
2048 }
2049 }
2050 #[automatically_derived]
2051 impl From<&RevokedTarget> for alloy_sol_types::private::LogData {
2052 #[inline]
2053 fn from(this: &RevokedTarget) -> alloy_sol_types::private::LogData {
2054 alloy_sol_types::SolEvent::encode_log_data(this)
2055 }
2056 }
2057 };
2058 #[derive(serde::Serialize, serde::Deserialize)]
2059 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2060 #[allow(
2065 non_camel_case_types,
2066 non_snake_case,
2067 clippy::pub_underscore_fields,
2068 clippy::style
2069 )]
2070 #[derive(Clone)]
2071 pub struct ScopedGranularChannelCapability {
2072 #[allow(missing_docs)]
2073 pub targetAddress: alloy::sol_types::private::Address,
2074 #[allow(missing_docs)]
2075 pub channelId: alloy::sol_types::private::FixedBytes<32>,
2076 #[allow(missing_docs)]
2077 pub selector: alloy::sol_types::private::FixedBytes<4>,
2078 #[allow(missing_docs)]
2079 pub permission: <GranularPermission as alloy::sol_types::SolType>::RustType,
2080 }
2081 #[allow(
2082 non_camel_case_types,
2083 non_snake_case,
2084 clippy::pub_underscore_fields,
2085 clippy::style
2086 )]
2087 const _: () = {
2088 use alloy::sol_types as alloy_sol_types;
2089 #[automatically_derived]
2090 impl alloy_sol_types::SolEvent for ScopedGranularChannelCapability {
2091 type DataTuple<'a> = (
2092 alloy::sol_types::sol_data::FixedBytes<4>,
2093 GranularPermission,
2094 );
2095 type DataToken<'a> = <Self::DataTuple<
2096 'a,
2097 > as alloy_sol_types::SolType>::Token<'a>;
2098 type TopicList = (
2099 alloy_sol_types::sol_data::FixedBytes<32>,
2100 alloy::sol_types::sol_data::Address,
2101 alloy::sol_types::sol_data::FixedBytes<32>,
2102 );
2103 const SIGNATURE: &'static str = "ScopedGranularChannelCapability(address,bytes32,bytes4,uint8)";
2104 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2105 242u8, 255u8, 212u8, 240u8, 157u8, 88u8, 208u8, 104u8, 36u8, 24u8, 128u8,
2106 51u8, 211u8, 49u8, 141u8, 6u8, 235u8, 149u8, 123u8, 251u8, 26u8, 143u8,
2107 254u8, 217u8, 175u8, 120u8, 225u8, 241u8, 145u8, 104u8, 185u8, 4u8,
2108 ]);
2109 const ANONYMOUS: bool = false;
2110 #[allow(unused_variables)]
2111 #[inline]
2112 fn new(
2113 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2114 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2115 ) -> Self {
2116 Self {
2117 targetAddress: topics.1,
2118 channelId: topics.2,
2119 selector: data.0,
2120 permission: data.1,
2121 }
2122 }
2123 #[inline]
2124 fn check_signature(
2125 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2126 ) -> alloy_sol_types::Result<()> {
2127 if topics.0 != Self::SIGNATURE_HASH {
2128 return Err(
2129 alloy_sol_types::Error::invalid_event_signature_hash(
2130 Self::SIGNATURE,
2131 topics.0,
2132 Self::SIGNATURE_HASH,
2133 ),
2134 );
2135 }
2136 Ok(())
2137 }
2138 #[inline]
2139 fn tokenize_body(&self) -> Self::DataToken<'_> {
2140 (
2141 <alloy::sol_types::sol_data::FixedBytes<
2142 4,
2143 > as alloy_sol_types::SolType>::tokenize(&self.selector),
2144 <GranularPermission as alloy_sol_types::SolType>::tokenize(
2145 &self.permission,
2146 ),
2147 )
2148 }
2149 #[inline]
2150 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2151 (
2152 Self::SIGNATURE_HASH.into(),
2153 self.targetAddress.clone(),
2154 self.channelId.clone(),
2155 )
2156 }
2157 #[inline]
2158 fn encode_topics_raw(
2159 &self,
2160 out: &mut [alloy_sol_types::abi::token::WordToken],
2161 ) -> alloy_sol_types::Result<()> {
2162 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2163 return Err(alloy_sol_types::Error::Overrun);
2164 }
2165 out[0usize] = alloy_sol_types::abi::token::WordToken(
2166 Self::SIGNATURE_HASH,
2167 );
2168 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2169 &self.targetAddress,
2170 );
2171 out[2usize] = <alloy::sol_types::sol_data::FixedBytes<
2172 32,
2173 > as alloy_sol_types::EventTopic>::encode_topic(&self.channelId);
2174 Ok(())
2175 }
2176 }
2177 #[automatically_derived]
2178 impl alloy_sol_types::private::IntoLogData for ScopedGranularChannelCapability {
2179 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2180 From::from(self)
2181 }
2182 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2183 From::from(&self)
2184 }
2185 }
2186 #[automatically_derived]
2187 impl From<&ScopedGranularChannelCapability>
2188 for alloy_sol_types::private::LogData {
2189 #[inline]
2190 fn from(
2191 this: &ScopedGranularChannelCapability,
2192 ) -> alloy_sol_types::private::LogData {
2193 alloy_sol_types::SolEvent::encode_log_data(this)
2194 }
2195 }
2196 };
2197 #[derive(serde::Serialize, serde::Deserialize)]
2198 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2199 #[allow(
2204 non_camel_case_types,
2205 non_snake_case,
2206 clippy::pub_underscore_fields,
2207 clippy::style
2208 )]
2209 #[derive(Clone)]
2210 pub struct ScopedGranularSendCapability {
2211 #[allow(missing_docs)]
2212 pub nodeAddress: alloy::sol_types::private::Address,
2213 #[allow(missing_docs)]
2214 pub recipientAddress: alloy::sol_types::private::Address,
2215 #[allow(missing_docs)]
2216 pub permission: <GranularPermission as alloy::sol_types::SolType>::RustType,
2217 }
2218 #[allow(
2219 non_camel_case_types,
2220 non_snake_case,
2221 clippy::pub_underscore_fields,
2222 clippy::style
2223 )]
2224 const _: () = {
2225 use alloy::sol_types as alloy_sol_types;
2226 #[automatically_derived]
2227 impl alloy_sol_types::SolEvent for ScopedGranularSendCapability {
2228 type DataTuple<'a> = (GranularPermission,);
2229 type DataToken<'a> = <Self::DataTuple<
2230 'a,
2231 > as alloy_sol_types::SolType>::Token<'a>;
2232 type TopicList = (
2233 alloy_sol_types::sol_data::FixedBytes<32>,
2234 alloy::sol_types::sol_data::Address,
2235 alloy::sol_types::sol_data::Address,
2236 );
2237 const SIGNATURE: &'static str = "ScopedGranularSendCapability(address,address,uint8)";
2238 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2239 116u8, 135u8, 83u8, 13u8, 223u8, 241u8, 32u8, 121u8, 149u8, 5u8, 229u8,
2240 43u8, 27u8, 25u8, 182u8, 147u8, 63u8, 133u8, 169u8, 238u8, 174u8, 146u8,
2241 32u8, 200u8, 10u8, 122u8, 215u8, 196u8, 41u8, 182u8, 18u8, 174u8,
2242 ]);
2243 const ANONYMOUS: bool = false;
2244 #[allow(unused_variables)]
2245 #[inline]
2246 fn new(
2247 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2248 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2249 ) -> Self {
2250 Self {
2251 nodeAddress: topics.1,
2252 recipientAddress: topics.2,
2253 permission: data.0,
2254 }
2255 }
2256 #[inline]
2257 fn check_signature(
2258 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2259 ) -> alloy_sol_types::Result<()> {
2260 if topics.0 != Self::SIGNATURE_HASH {
2261 return Err(
2262 alloy_sol_types::Error::invalid_event_signature_hash(
2263 Self::SIGNATURE,
2264 topics.0,
2265 Self::SIGNATURE_HASH,
2266 ),
2267 );
2268 }
2269 Ok(())
2270 }
2271 #[inline]
2272 fn tokenize_body(&self) -> Self::DataToken<'_> {
2273 (
2274 <GranularPermission as alloy_sol_types::SolType>::tokenize(
2275 &self.permission,
2276 ),
2277 )
2278 }
2279 #[inline]
2280 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2281 (
2282 Self::SIGNATURE_HASH.into(),
2283 self.nodeAddress.clone(),
2284 self.recipientAddress.clone(),
2285 )
2286 }
2287 #[inline]
2288 fn encode_topics_raw(
2289 &self,
2290 out: &mut [alloy_sol_types::abi::token::WordToken],
2291 ) -> alloy_sol_types::Result<()> {
2292 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2293 return Err(alloy_sol_types::Error::Overrun);
2294 }
2295 out[0usize] = alloy_sol_types::abi::token::WordToken(
2296 Self::SIGNATURE_HASH,
2297 );
2298 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2299 &self.nodeAddress,
2300 );
2301 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2302 &self.recipientAddress,
2303 );
2304 Ok(())
2305 }
2306 }
2307 #[automatically_derived]
2308 impl alloy_sol_types::private::IntoLogData for ScopedGranularSendCapability {
2309 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2310 From::from(self)
2311 }
2312 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2313 From::from(&self)
2314 }
2315 }
2316 #[automatically_derived]
2317 impl From<&ScopedGranularSendCapability> for alloy_sol_types::private::LogData {
2318 #[inline]
2319 fn from(
2320 this: &ScopedGranularSendCapability,
2321 ) -> alloy_sol_types::private::LogData {
2322 alloy_sol_types::SolEvent::encode_log_data(this)
2323 }
2324 }
2325 };
2326 #[derive(serde::Serialize, serde::Deserialize)]
2327 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2328 #[allow(
2333 non_camel_case_types,
2334 non_snake_case,
2335 clippy::pub_underscore_fields,
2336 clippy::style
2337 )]
2338 #[derive(Clone)]
2339 pub struct ScopedGranularTokenCapability {
2340 #[allow(missing_docs)]
2341 pub nodeAddress: alloy::sol_types::private::Address,
2342 #[allow(missing_docs)]
2343 pub targetAddress: alloy::sol_types::private::Address,
2344 #[allow(missing_docs)]
2345 pub recipientAddress: alloy::sol_types::private::Address,
2346 #[allow(missing_docs)]
2347 pub selector: alloy::sol_types::private::FixedBytes<4>,
2348 #[allow(missing_docs)]
2349 pub permission: <GranularPermission as alloy::sol_types::SolType>::RustType,
2350 }
2351 #[allow(
2352 non_camel_case_types,
2353 non_snake_case,
2354 clippy::pub_underscore_fields,
2355 clippy::style
2356 )]
2357 const _: () = {
2358 use alloy::sol_types as alloy_sol_types;
2359 #[automatically_derived]
2360 impl alloy_sol_types::SolEvent for ScopedGranularTokenCapability {
2361 type DataTuple<'a> = (
2362 alloy::sol_types::sol_data::FixedBytes<4>,
2363 GranularPermission,
2364 );
2365 type DataToken<'a> = <Self::DataTuple<
2366 'a,
2367 > as alloy_sol_types::SolType>::Token<'a>;
2368 type TopicList = (
2369 alloy_sol_types::sol_data::FixedBytes<32>,
2370 alloy::sol_types::sol_data::Address,
2371 alloy::sol_types::sol_data::Address,
2372 alloy::sol_types::sol_data::Address,
2373 );
2374 const SIGNATURE: &'static str = "ScopedGranularTokenCapability(address,address,address,bytes4,uint8)";
2375 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2376 163u8, 223u8, 113u8, 4u8, 32u8, 176u8, 28u8, 195u8, 15u8, 243u8, 0u8,
2377 48u8, 154u8, 187u8, 199u8, 250u8, 221u8, 70u8, 48u8, 212u8, 171u8, 56u8,
2378 91u8, 15u8, 90u8, 18u8, 111u8, 180u8, 186u8, 190u8, 118u8, 43u8,
2379 ]);
2380 const ANONYMOUS: bool = false;
2381 #[allow(unused_variables)]
2382 #[inline]
2383 fn new(
2384 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2385 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2386 ) -> Self {
2387 Self {
2388 nodeAddress: topics.1,
2389 targetAddress: topics.2,
2390 recipientAddress: topics.3,
2391 selector: data.0,
2392 permission: data.1,
2393 }
2394 }
2395 #[inline]
2396 fn check_signature(
2397 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2398 ) -> alloy_sol_types::Result<()> {
2399 if topics.0 != Self::SIGNATURE_HASH {
2400 return Err(
2401 alloy_sol_types::Error::invalid_event_signature_hash(
2402 Self::SIGNATURE,
2403 topics.0,
2404 Self::SIGNATURE_HASH,
2405 ),
2406 );
2407 }
2408 Ok(())
2409 }
2410 #[inline]
2411 fn tokenize_body(&self) -> Self::DataToken<'_> {
2412 (
2413 <alloy::sol_types::sol_data::FixedBytes<
2414 4,
2415 > as alloy_sol_types::SolType>::tokenize(&self.selector),
2416 <GranularPermission as alloy_sol_types::SolType>::tokenize(
2417 &self.permission,
2418 ),
2419 )
2420 }
2421 #[inline]
2422 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2423 (
2424 Self::SIGNATURE_HASH.into(),
2425 self.nodeAddress.clone(),
2426 self.targetAddress.clone(),
2427 self.recipientAddress.clone(),
2428 )
2429 }
2430 #[inline]
2431 fn encode_topics_raw(
2432 &self,
2433 out: &mut [alloy_sol_types::abi::token::WordToken],
2434 ) -> alloy_sol_types::Result<()> {
2435 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2436 return Err(alloy_sol_types::Error::Overrun);
2437 }
2438 out[0usize] = alloy_sol_types::abi::token::WordToken(
2439 Self::SIGNATURE_HASH,
2440 );
2441 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2442 &self.nodeAddress,
2443 );
2444 out[2usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2445 &self.targetAddress,
2446 );
2447 out[3usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2448 &self.recipientAddress,
2449 );
2450 Ok(())
2451 }
2452 }
2453 #[automatically_derived]
2454 impl alloy_sol_types::private::IntoLogData for ScopedGranularTokenCapability {
2455 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2456 From::from(self)
2457 }
2458 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2459 From::from(&self)
2460 }
2461 }
2462 #[automatically_derived]
2463 impl From<&ScopedGranularTokenCapability> for alloy_sol_types::private::LogData {
2464 #[inline]
2465 fn from(
2466 this: &ScopedGranularTokenCapability,
2467 ) -> alloy_sol_types::private::LogData {
2468 alloy_sol_types::SolEvent::encode_log_data(this)
2469 }
2470 }
2471 };
2472 #[derive(serde::Serialize, serde::Deserialize)]
2473 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2474 #[allow(
2479 non_camel_case_types,
2480 non_snake_case,
2481 clippy::pub_underscore_fields,
2482 clippy::style
2483 )]
2484 #[derive(Clone)]
2485 pub struct ScopedTargetChannels {
2486 #[allow(missing_docs)]
2487 pub targetAddress: alloy::sol_types::private::Address,
2488 #[allow(missing_docs)]
2489 pub target: <Target as alloy::sol_types::SolType>::RustType,
2490 }
2491 #[allow(
2492 non_camel_case_types,
2493 non_snake_case,
2494 clippy::pub_underscore_fields,
2495 clippy::style
2496 )]
2497 const _: () = {
2498 use alloy::sol_types as alloy_sol_types;
2499 #[automatically_derived]
2500 impl alloy_sol_types::SolEvent for ScopedTargetChannels {
2501 type DataTuple<'a> = (Target,);
2502 type DataToken<'a> = <Self::DataTuple<
2503 'a,
2504 > as alloy_sol_types::SolType>::Token<'a>;
2505 type TopicList = (
2506 alloy_sol_types::sol_data::FixedBytes<32>,
2507 alloy::sol_types::sol_data::Address,
2508 );
2509 const SIGNATURE: &'static str = "ScopedTargetChannels(address,uint256)";
2510 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2511 95u8, 251u8, 6u8, 176u8, 176u8, 232u8, 173u8, 106u8, 143u8, 60u8, 88u8,
2512 49u8, 212u8, 153u8, 223u8, 166u8, 18u8, 217u8, 201u8, 212u8, 220u8, 16u8,
2513 123u8, 189u8, 102u8, 241u8, 143u8, 97u8, 166u8, 73u8, 46u8, 113u8,
2514 ]);
2515 const ANONYMOUS: bool = false;
2516 #[allow(unused_variables)]
2517 #[inline]
2518 fn new(
2519 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2520 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2521 ) -> Self {
2522 Self {
2523 targetAddress: topics.1,
2524 target: data.0,
2525 }
2526 }
2527 #[inline]
2528 fn check_signature(
2529 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2530 ) -> alloy_sol_types::Result<()> {
2531 if topics.0 != Self::SIGNATURE_HASH {
2532 return Err(
2533 alloy_sol_types::Error::invalid_event_signature_hash(
2534 Self::SIGNATURE,
2535 topics.0,
2536 Self::SIGNATURE_HASH,
2537 ),
2538 );
2539 }
2540 Ok(())
2541 }
2542 #[inline]
2543 fn tokenize_body(&self) -> Self::DataToken<'_> {
2544 (<Target as alloy_sol_types::SolType>::tokenize(&self.target),)
2545 }
2546 #[inline]
2547 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2548 (Self::SIGNATURE_HASH.into(), self.targetAddress.clone())
2549 }
2550 #[inline]
2551 fn encode_topics_raw(
2552 &self,
2553 out: &mut [alloy_sol_types::abi::token::WordToken],
2554 ) -> alloy_sol_types::Result<()> {
2555 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2556 return Err(alloy_sol_types::Error::Overrun);
2557 }
2558 out[0usize] = alloy_sol_types::abi::token::WordToken(
2559 Self::SIGNATURE_HASH,
2560 );
2561 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2562 &self.targetAddress,
2563 );
2564 Ok(())
2565 }
2566 }
2567 #[automatically_derived]
2568 impl alloy_sol_types::private::IntoLogData for ScopedTargetChannels {
2569 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2570 From::from(self)
2571 }
2572 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2573 From::from(&self)
2574 }
2575 }
2576 #[automatically_derived]
2577 impl From<&ScopedTargetChannels> for alloy_sol_types::private::LogData {
2578 #[inline]
2579 fn from(this: &ScopedTargetChannels) -> alloy_sol_types::private::LogData {
2580 alloy_sol_types::SolEvent::encode_log_data(this)
2581 }
2582 }
2583 };
2584 #[derive(serde::Serialize, serde::Deserialize)]
2585 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2586 #[allow(
2591 non_camel_case_types,
2592 non_snake_case,
2593 clippy::pub_underscore_fields,
2594 clippy::style
2595 )]
2596 #[derive(Clone)]
2597 pub struct ScopedTargetSend {
2598 #[allow(missing_docs)]
2599 pub targetAddress: alloy::sol_types::private::Address,
2600 #[allow(missing_docs)]
2601 pub target: <Target as alloy::sol_types::SolType>::RustType,
2602 }
2603 #[allow(
2604 non_camel_case_types,
2605 non_snake_case,
2606 clippy::pub_underscore_fields,
2607 clippy::style
2608 )]
2609 const _: () = {
2610 use alloy::sol_types as alloy_sol_types;
2611 #[automatically_derived]
2612 impl alloy_sol_types::SolEvent for ScopedTargetSend {
2613 type DataTuple<'a> = (Target,);
2614 type DataToken<'a> = <Self::DataTuple<
2615 'a,
2616 > as alloy_sol_types::SolType>::Token<'a>;
2617 type TopicList = (
2618 alloy_sol_types::sol_data::FixedBytes<32>,
2619 alloy::sol_types::sol_data::Address,
2620 );
2621 const SIGNATURE: &'static str = "ScopedTargetSend(address,uint256)";
2622 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2623 30u8, 226u8, 121u8, 31u8, 44u8, 175u8, 14u8, 146u8, 169u8, 220u8, 50u8,
2624 163u8, 122u8, 158u8, 165u8, 58u8, 182u8, 172u8, 122u8, 111u8, 184u8,
2625 242u8, 208u8, 144u8, 229u8, 58u8, 6u8, 125u8, 58u8, 67u8, 246u8, 172u8,
2626 ]);
2627 const ANONYMOUS: bool = false;
2628 #[allow(unused_variables)]
2629 #[inline]
2630 fn new(
2631 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2632 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2633 ) -> Self {
2634 Self {
2635 targetAddress: topics.1,
2636 target: data.0,
2637 }
2638 }
2639 #[inline]
2640 fn check_signature(
2641 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2642 ) -> alloy_sol_types::Result<()> {
2643 if topics.0 != Self::SIGNATURE_HASH {
2644 return Err(
2645 alloy_sol_types::Error::invalid_event_signature_hash(
2646 Self::SIGNATURE,
2647 topics.0,
2648 Self::SIGNATURE_HASH,
2649 ),
2650 );
2651 }
2652 Ok(())
2653 }
2654 #[inline]
2655 fn tokenize_body(&self) -> Self::DataToken<'_> {
2656 (<Target as alloy_sol_types::SolType>::tokenize(&self.target),)
2657 }
2658 #[inline]
2659 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2660 (Self::SIGNATURE_HASH.into(), self.targetAddress.clone())
2661 }
2662 #[inline]
2663 fn encode_topics_raw(
2664 &self,
2665 out: &mut [alloy_sol_types::abi::token::WordToken],
2666 ) -> alloy_sol_types::Result<()> {
2667 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2668 return Err(alloy_sol_types::Error::Overrun);
2669 }
2670 out[0usize] = alloy_sol_types::abi::token::WordToken(
2671 Self::SIGNATURE_HASH,
2672 );
2673 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2674 &self.targetAddress,
2675 );
2676 Ok(())
2677 }
2678 }
2679 #[automatically_derived]
2680 impl alloy_sol_types::private::IntoLogData for ScopedTargetSend {
2681 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2682 From::from(self)
2683 }
2684 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2685 From::from(&self)
2686 }
2687 }
2688 #[automatically_derived]
2689 impl From<&ScopedTargetSend> for alloy_sol_types::private::LogData {
2690 #[inline]
2691 fn from(this: &ScopedTargetSend) -> alloy_sol_types::private::LogData {
2692 alloy_sol_types::SolEvent::encode_log_data(this)
2693 }
2694 }
2695 };
2696 #[derive(serde::Serialize, serde::Deserialize)]
2697 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2698 #[allow(
2703 non_camel_case_types,
2704 non_snake_case,
2705 clippy::pub_underscore_fields,
2706 clippy::style
2707 )]
2708 #[derive(Clone)]
2709 pub struct ScopedTargetToken {
2710 #[allow(missing_docs)]
2711 pub targetAddress: alloy::sol_types::private::Address,
2712 #[allow(missing_docs)]
2713 pub target: <Target as alloy::sol_types::SolType>::RustType,
2714 }
2715 #[allow(
2716 non_camel_case_types,
2717 non_snake_case,
2718 clippy::pub_underscore_fields,
2719 clippy::style
2720 )]
2721 const _: () = {
2722 use alloy::sol_types as alloy_sol_types;
2723 #[automatically_derived]
2724 impl alloy_sol_types::SolEvent for ScopedTargetToken {
2725 type DataTuple<'a> = (Target,);
2726 type DataToken<'a> = <Self::DataTuple<
2727 'a,
2728 > as alloy_sol_types::SolType>::Token<'a>;
2729 type TopicList = (
2730 alloy_sol_types::sol_data::FixedBytes<32>,
2731 alloy::sol_types::sol_data::Address,
2732 );
2733 const SIGNATURE: &'static str = "ScopedTargetToken(address,uint256)";
2734 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
2735 170u8, 242u8, 107u8, 177u8, 42u8, 168u8, 158u8, 233u8, 107u8, 190u8,
2736 25u8, 102u8, 122u8, 106u8, 5u8, 87u8, 39u8, 183u8, 93u8, 63u8, 110u8,
2737 215u8, 184u8, 182u8, 17u8, 239u8, 101u8, 25u8, 24u8, 2u8, 9u8, 214u8,
2738 ]);
2739 const ANONYMOUS: bool = false;
2740 #[allow(unused_variables)]
2741 #[inline]
2742 fn new(
2743 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
2744 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
2745 ) -> Self {
2746 Self {
2747 targetAddress: topics.1,
2748 target: data.0,
2749 }
2750 }
2751 #[inline]
2752 fn check_signature(
2753 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
2754 ) -> alloy_sol_types::Result<()> {
2755 if topics.0 != Self::SIGNATURE_HASH {
2756 return Err(
2757 alloy_sol_types::Error::invalid_event_signature_hash(
2758 Self::SIGNATURE,
2759 topics.0,
2760 Self::SIGNATURE_HASH,
2761 ),
2762 );
2763 }
2764 Ok(())
2765 }
2766 #[inline]
2767 fn tokenize_body(&self) -> Self::DataToken<'_> {
2768 (<Target as alloy_sol_types::SolType>::tokenize(&self.target),)
2769 }
2770 #[inline]
2771 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
2772 (Self::SIGNATURE_HASH.into(), self.targetAddress.clone())
2773 }
2774 #[inline]
2775 fn encode_topics_raw(
2776 &self,
2777 out: &mut [alloy_sol_types::abi::token::WordToken],
2778 ) -> alloy_sol_types::Result<()> {
2779 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
2780 return Err(alloy_sol_types::Error::Overrun);
2781 }
2782 out[0usize] = alloy_sol_types::abi::token::WordToken(
2783 Self::SIGNATURE_HASH,
2784 );
2785 out[1usize] = <alloy::sol_types::sol_data::Address as alloy_sol_types::EventTopic>::encode_topic(
2786 &self.targetAddress,
2787 );
2788 Ok(())
2789 }
2790 }
2791 #[automatically_derived]
2792 impl alloy_sol_types::private::IntoLogData for ScopedTargetToken {
2793 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
2794 From::from(self)
2795 }
2796 fn into_log_data(self) -> alloy_sol_types::private::LogData {
2797 From::from(&self)
2798 }
2799 }
2800 #[automatically_derived]
2801 impl From<&ScopedTargetToken> for alloy_sol_types::private::LogData {
2802 #[inline]
2803 fn from(this: &ScopedTargetToken) -> alloy_sol_types::private::LogData {
2804 alloy_sol_types::SolEvent::encode_log_data(this)
2805 }
2806 }
2807 };
2808 #[derive(serde::Serialize, serde::Deserialize)]
2809 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2810 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2815 #[derive(Clone)]
2816 pub struct APPROVE_SELECTORCall;
2817 #[derive(serde::Serialize, serde::Deserialize)]
2818 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2819 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2821 #[derive(Clone)]
2822 pub struct APPROVE_SELECTORReturn {
2823 #[allow(missing_docs)]
2824 pub _0: alloy::sol_types::private::FixedBytes<4>,
2825 }
2826 #[allow(
2827 non_camel_case_types,
2828 non_snake_case,
2829 clippy::pub_underscore_fields,
2830 clippy::style
2831 )]
2832 const _: () = {
2833 use alloy::sol_types as alloy_sol_types;
2834 {
2835 #[doc(hidden)]
2836 type UnderlyingSolTuple<'a> = ();
2837 #[doc(hidden)]
2838 type UnderlyingRustTuple<'a> = ();
2839 #[cfg(test)]
2840 #[allow(dead_code, unreachable_patterns)]
2841 fn _type_assertion(
2842 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2843 ) {
2844 match _t {
2845 alloy_sol_types::private::AssertTypeEq::<
2846 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2847 >(_) => {}
2848 }
2849 }
2850 #[automatically_derived]
2851 #[doc(hidden)]
2852 impl ::core::convert::From<APPROVE_SELECTORCall>
2853 for UnderlyingRustTuple<'_> {
2854 fn from(value: APPROVE_SELECTORCall) -> Self {
2855 ()
2856 }
2857 }
2858 #[automatically_derived]
2859 #[doc(hidden)]
2860 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2861 for APPROVE_SELECTORCall {
2862 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2863 Self
2864 }
2865 }
2866 }
2867 {
2868 #[doc(hidden)]
2869 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
2870 #[doc(hidden)]
2871 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
2872 #[cfg(test)]
2873 #[allow(dead_code, unreachable_patterns)]
2874 fn _type_assertion(
2875 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2876 ) {
2877 match _t {
2878 alloy_sol_types::private::AssertTypeEq::<
2879 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2880 >(_) => {}
2881 }
2882 }
2883 #[automatically_derived]
2884 #[doc(hidden)]
2885 impl ::core::convert::From<APPROVE_SELECTORReturn>
2886 for UnderlyingRustTuple<'_> {
2887 fn from(value: APPROVE_SELECTORReturn) -> Self {
2888 (value._0,)
2889 }
2890 }
2891 #[automatically_derived]
2892 #[doc(hidden)]
2893 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2894 for APPROVE_SELECTORReturn {
2895 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2896 Self { _0: tuple.0 }
2897 }
2898 }
2899 }
2900 #[automatically_derived]
2901 impl alloy_sol_types::SolCall for APPROVE_SELECTORCall {
2902 type Parameters<'a> = ();
2903 type Token<'a> = <Self::Parameters<
2904 'a,
2905 > as alloy_sol_types::SolType>::Token<'a>;
2906 type Return = alloy::sol_types::private::FixedBytes<4>;
2907 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
2908 type ReturnToken<'a> = <Self::ReturnTuple<
2909 'a,
2910 > as alloy_sol_types::SolType>::Token<'a>;
2911 const SIGNATURE: &'static str = "APPROVE_SELECTOR()";
2912 const SELECTOR: [u8; 4] = [160u8, 134u8, 88u8, 57u8];
2913 #[inline]
2914 fn new<'a>(
2915 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2916 ) -> Self {
2917 tuple.into()
2918 }
2919 #[inline]
2920 fn tokenize(&self) -> Self::Token<'_> {
2921 ()
2922 }
2923 #[inline]
2924 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
2925 (
2926 <alloy::sol_types::sol_data::FixedBytes<
2927 4,
2928 > as alloy_sol_types::SolType>::tokenize(ret),
2929 )
2930 }
2931 #[inline]
2932 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
2933 <Self::ReturnTuple<
2934 '_,
2935 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
2936 .map(|r| {
2937 let r: APPROVE_SELECTORReturn = r.into();
2938 r._0
2939 })
2940 }
2941 #[inline]
2942 fn abi_decode_returns_validate(
2943 data: &[u8],
2944 ) -> alloy_sol_types::Result<Self::Return> {
2945 <Self::ReturnTuple<
2946 '_,
2947 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
2948 .map(|r| {
2949 let r: APPROVE_SELECTORReturn = r.into();
2950 r._0
2951 })
2952 }
2953 }
2954 };
2955 #[derive(serde::Serialize, serde::Deserialize)]
2956 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2957 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2962 #[derive(Clone)]
2963 pub struct CLOSE_INCOMING_CHANNEL_SELECTORCall;
2964 #[derive(serde::Serialize, serde::Deserialize)]
2965 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2966 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2968 #[derive(Clone)]
2969 pub struct CLOSE_INCOMING_CHANNEL_SELECTORReturn {
2970 #[allow(missing_docs)]
2971 pub _0: alloy::sol_types::private::FixedBytes<4>,
2972 }
2973 #[allow(
2974 non_camel_case_types,
2975 non_snake_case,
2976 clippy::pub_underscore_fields,
2977 clippy::style
2978 )]
2979 const _: () = {
2980 use alloy::sol_types as alloy_sol_types;
2981 {
2982 #[doc(hidden)]
2983 type UnderlyingSolTuple<'a> = ();
2984 #[doc(hidden)]
2985 type UnderlyingRustTuple<'a> = ();
2986 #[cfg(test)]
2987 #[allow(dead_code, unreachable_patterns)]
2988 fn _type_assertion(
2989 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2990 ) {
2991 match _t {
2992 alloy_sol_types::private::AssertTypeEq::<
2993 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2994 >(_) => {}
2995 }
2996 }
2997 #[automatically_derived]
2998 #[doc(hidden)]
2999 impl ::core::convert::From<CLOSE_INCOMING_CHANNEL_SELECTORCall>
3000 for UnderlyingRustTuple<'_> {
3001 fn from(value: CLOSE_INCOMING_CHANNEL_SELECTORCall) -> Self {
3002 ()
3003 }
3004 }
3005 #[automatically_derived]
3006 #[doc(hidden)]
3007 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3008 for CLOSE_INCOMING_CHANNEL_SELECTORCall {
3009 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3010 Self
3011 }
3012 }
3013 }
3014 {
3015 #[doc(hidden)]
3016 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3017 #[doc(hidden)]
3018 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3019 #[cfg(test)]
3020 #[allow(dead_code, unreachable_patterns)]
3021 fn _type_assertion(
3022 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3023 ) {
3024 match _t {
3025 alloy_sol_types::private::AssertTypeEq::<
3026 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3027 >(_) => {}
3028 }
3029 }
3030 #[automatically_derived]
3031 #[doc(hidden)]
3032 impl ::core::convert::From<CLOSE_INCOMING_CHANNEL_SELECTORReturn>
3033 for UnderlyingRustTuple<'_> {
3034 fn from(value: CLOSE_INCOMING_CHANNEL_SELECTORReturn) -> Self {
3035 (value._0,)
3036 }
3037 }
3038 #[automatically_derived]
3039 #[doc(hidden)]
3040 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3041 for CLOSE_INCOMING_CHANNEL_SELECTORReturn {
3042 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3043 Self { _0: tuple.0 }
3044 }
3045 }
3046 }
3047 #[automatically_derived]
3048 impl alloy_sol_types::SolCall for CLOSE_INCOMING_CHANNEL_SELECTORCall {
3049 type Parameters<'a> = ();
3050 type Token<'a> = <Self::Parameters<
3051 'a,
3052 > as alloy_sol_types::SolType>::Token<'a>;
3053 type Return = alloy::sol_types::private::FixedBytes<4>;
3054 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3055 type ReturnToken<'a> = <Self::ReturnTuple<
3056 'a,
3057 > as alloy_sol_types::SolType>::Token<'a>;
3058 const SIGNATURE: &'static str = "CLOSE_INCOMING_CHANNEL_SELECTOR()";
3059 const SELECTOR: [u8; 4] = [103u8, 138u8, 94u8, 251u8];
3060 #[inline]
3061 fn new<'a>(
3062 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3063 ) -> Self {
3064 tuple.into()
3065 }
3066 #[inline]
3067 fn tokenize(&self) -> Self::Token<'_> {
3068 ()
3069 }
3070 #[inline]
3071 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3072 (
3073 <alloy::sol_types::sol_data::FixedBytes<
3074 4,
3075 > as alloy_sol_types::SolType>::tokenize(ret),
3076 )
3077 }
3078 #[inline]
3079 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3080 <Self::ReturnTuple<
3081 '_,
3082 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3083 .map(|r| {
3084 let r: CLOSE_INCOMING_CHANNEL_SELECTORReturn = r.into();
3085 r._0
3086 })
3087 }
3088 #[inline]
3089 fn abi_decode_returns_validate(
3090 data: &[u8],
3091 ) -> alloy_sol_types::Result<Self::Return> {
3092 <Self::ReturnTuple<
3093 '_,
3094 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3095 .map(|r| {
3096 let r: CLOSE_INCOMING_CHANNEL_SELECTORReturn = r.into();
3097 r._0
3098 })
3099 }
3100 }
3101 };
3102 #[derive(serde::Serialize, serde::Deserialize)]
3103 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3104 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3109 #[derive(Clone)]
3110 pub struct FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall;
3111 #[derive(serde::Serialize, serde::Deserialize)]
3112 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3113 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3115 #[derive(Clone)]
3116 pub struct FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn {
3117 #[allow(missing_docs)]
3118 pub _0: alloy::sol_types::private::FixedBytes<4>,
3119 }
3120 #[allow(
3121 non_camel_case_types,
3122 non_snake_case,
3123 clippy::pub_underscore_fields,
3124 clippy::style
3125 )]
3126 const _: () = {
3127 use alloy::sol_types as alloy_sol_types;
3128 {
3129 #[doc(hidden)]
3130 type UnderlyingSolTuple<'a> = ();
3131 #[doc(hidden)]
3132 type UnderlyingRustTuple<'a> = ();
3133 #[cfg(test)]
3134 #[allow(dead_code, unreachable_patterns)]
3135 fn _type_assertion(
3136 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3137 ) {
3138 match _t {
3139 alloy_sol_types::private::AssertTypeEq::<
3140 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3141 >(_) => {}
3142 }
3143 }
3144 #[automatically_derived]
3145 #[doc(hidden)]
3146 impl ::core::convert::From<FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall>
3147 for UnderlyingRustTuple<'_> {
3148 fn from(value: FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall) -> Self {
3149 ()
3150 }
3151 }
3152 #[automatically_derived]
3153 #[doc(hidden)]
3154 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3155 for FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall {
3156 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3157 Self
3158 }
3159 }
3160 }
3161 {
3162 #[doc(hidden)]
3163 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3164 #[doc(hidden)]
3165 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3166 #[cfg(test)]
3167 #[allow(dead_code, unreachable_patterns)]
3168 fn _type_assertion(
3169 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3170 ) {
3171 match _t {
3172 alloy_sol_types::private::AssertTypeEq::<
3173 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3174 >(_) => {}
3175 }
3176 }
3177 #[automatically_derived]
3178 #[doc(hidden)]
3179 impl ::core::convert::From<FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn>
3180 for UnderlyingRustTuple<'_> {
3181 fn from(
3182 value: FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn,
3183 ) -> Self {
3184 (value._0,)
3185 }
3186 }
3187 #[automatically_derived]
3188 #[doc(hidden)]
3189 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3190 for FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn {
3191 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3192 Self { _0: tuple.0 }
3193 }
3194 }
3195 }
3196 #[automatically_derived]
3197 impl alloy_sol_types::SolCall
3198 for FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall {
3199 type Parameters<'a> = ();
3200 type Token<'a> = <Self::Parameters<
3201 'a,
3202 > as alloy_sol_types::SolType>::Token<'a>;
3203 type Return = alloy::sol_types::private::FixedBytes<4>;
3204 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3205 type ReturnToken<'a> = <Self::ReturnTuple<
3206 'a,
3207 > as alloy_sol_types::SolType>::Token<'a>;
3208 const SIGNATURE: &'static str = "FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR()";
3209 const SELECTOR: [u8; 4] = [129u8, 103u8, 182u8, 126u8];
3210 #[inline]
3211 fn new<'a>(
3212 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3213 ) -> Self {
3214 tuple.into()
3215 }
3216 #[inline]
3217 fn tokenize(&self) -> Self::Token<'_> {
3218 ()
3219 }
3220 #[inline]
3221 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3222 (
3223 <alloy::sol_types::sol_data::FixedBytes<
3224 4,
3225 > as alloy_sol_types::SolType>::tokenize(ret),
3226 )
3227 }
3228 #[inline]
3229 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3230 <Self::ReturnTuple<
3231 '_,
3232 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3233 .map(|r| {
3234 let r: FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn = r
3235 .into();
3236 r._0
3237 })
3238 }
3239 #[inline]
3240 fn abi_decode_returns_validate(
3241 data: &[u8],
3242 ) -> alloy_sol_types::Result<Self::Return> {
3243 <Self::ReturnTuple<
3244 '_,
3245 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3246 .map(|r| {
3247 let r: FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn = r
3248 .into();
3249 r._0
3250 })
3251 }
3252 }
3253 };
3254 #[derive(serde::Serialize, serde::Deserialize)]
3255 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3256 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3261 #[derive(Clone)]
3262 pub struct FUND_CHANNEL_SELECTORCall;
3263 #[derive(serde::Serialize, serde::Deserialize)]
3264 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3265 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3267 #[derive(Clone)]
3268 pub struct FUND_CHANNEL_SELECTORReturn {
3269 #[allow(missing_docs)]
3270 pub _0: alloy::sol_types::private::FixedBytes<4>,
3271 }
3272 #[allow(
3273 non_camel_case_types,
3274 non_snake_case,
3275 clippy::pub_underscore_fields,
3276 clippy::style
3277 )]
3278 const _: () = {
3279 use alloy::sol_types as alloy_sol_types;
3280 {
3281 #[doc(hidden)]
3282 type UnderlyingSolTuple<'a> = ();
3283 #[doc(hidden)]
3284 type UnderlyingRustTuple<'a> = ();
3285 #[cfg(test)]
3286 #[allow(dead_code, unreachable_patterns)]
3287 fn _type_assertion(
3288 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3289 ) {
3290 match _t {
3291 alloy_sol_types::private::AssertTypeEq::<
3292 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3293 >(_) => {}
3294 }
3295 }
3296 #[automatically_derived]
3297 #[doc(hidden)]
3298 impl ::core::convert::From<FUND_CHANNEL_SELECTORCall>
3299 for UnderlyingRustTuple<'_> {
3300 fn from(value: FUND_CHANNEL_SELECTORCall) -> Self {
3301 ()
3302 }
3303 }
3304 #[automatically_derived]
3305 #[doc(hidden)]
3306 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3307 for FUND_CHANNEL_SELECTORCall {
3308 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3309 Self
3310 }
3311 }
3312 }
3313 {
3314 #[doc(hidden)]
3315 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3316 #[doc(hidden)]
3317 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3318 #[cfg(test)]
3319 #[allow(dead_code, unreachable_patterns)]
3320 fn _type_assertion(
3321 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3322 ) {
3323 match _t {
3324 alloy_sol_types::private::AssertTypeEq::<
3325 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3326 >(_) => {}
3327 }
3328 }
3329 #[automatically_derived]
3330 #[doc(hidden)]
3331 impl ::core::convert::From<FUND_CHANNEL_SELECTORReturn>
3332 for UnderlyingRustTuple<'_> {
3333 fn from(value: FUND_CHANNEL_SELECTORReturn) -> Self {
3334 (value._0,)
3335 }
3336 }
3337 #[automatically_derived]
3338 #[doc(hidden)]
3339 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3340 for FUND_CHANNEL_SELECTORReturn {
3341 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3342 Self { _0: tuple.0 }
3343 }
3344 }
3345 }
3346 #[automatically_derived]
3347 impl alloy_sol_types::SolCall for FUND_CHANNEL_SELECTORCall {
3348 type Parameters<'a> = ();
3349 type Token<'a> = <Self::Parameters<
3350 'a,
3351 > as alloy_sol_types::SolType>::Token<'a>;
3352 type Return = alloy::sol_types::private::FixedBytes<4>;
3353 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3354 type ReturnToken<'a> = <Self::ReturnTuple<
3355 'a,
3356 > as alloy_sol_types::SolType>::Token<'a>;
3357 const SIGNATURE: &'static str = "FUND_CHANNEL_SELECTOR()";
3358 const SELECTOR: [u8; 4] = [182u8, 119u8, 164u8, 15u8];
3359 #[inline]
3360 fn new<'a>(
3361 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3362 ) -> Self {
3363 tuple.into()
3364 }
3365 #[inline]
3366 fn tokenize(&self) -> Self::Token<'_> {
3367 ()
3368 }
3369 #[inline]
3370 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3371 (
3372 <alloy::sol_types::sol_data::FixedBytes<
3373 4,
3374 > as alloy_sol_types::SolType>::tokenize(ret),
3375 )
3376 }
3377 #[inline]
3378 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3379 <Self::ReturnTuple<
3380 '_,
3381 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3382 .map(|r| {
3383 let r: FUND_CHANNEL_SELECTORReturn = r.into();
3384 r._0
3385 })
3386 }
3387 #[inline]
3388 fn abi_decode_returns_validate(
3389 data: &[u8],
3390 ) -> alloy_sol_types::Result<Self::Return> {
3391 <Self::ReturnTuple<
3392 '_,
3393 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3394 .map(|r| {
3395 let r: FUND_CHANNEL_SELECTORReturn = r.into();
3396 r._0
3397 })
3398 }
3399 }
3400 };
3401 #[derive(serde::Serialize, serde::Deserialize)]
3402 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3403 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3408 #[derive(Clone)]
3409 pub struct INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall;
3410 #[derive(serde::Serialize, serde::Deserialize)]
3411 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3412 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3414 #[derive(Clone)]
3415 pub struct INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn {
3416 #[allow(missing_docs)]
3417 pub _0: alloy::sol_types::private::FixedBytes<4>,
3418 }
3419 #[allow(
3420 non_camel_case_types,
3421 non_snake_case,
3422 clippy::pub_underscore_fields,
3423 clippy::style
3424 )]
3425 const _: () = {
3426 use alloy::sol_types as alloy_sol_types;
3427 {
3428 #[doc(hidden)]
3429 type UnderlyingSolTuple<'a> = ();
3430 #[doc(hidden)]
3431 type UnderlyingRustTuple<'a> = ();
3432 #[cfg(test)]
3433 #[allow(dead_code, unreachable_patterns)]
3434 fn _type_assertion(
3435 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3436 ) {
3437 match _t {
3438 alloy_sol_types::private::AssertTypeEq::<
3439 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3440 >(_) => {}
3441 }
3442 }
3443 #[automatically_derived]
3444 #[doc(hidden)]
3445 impl ::core::convert::From<INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall>
3446 for UnderlyingRustTuple<'_> {
3447 fn from(value: INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall) -> Self {
3448 ()
3449 }
3450 }
3451 #[automatically_derived]
3452 #[doc(hidden)]
3453 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3454 for INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall {
3455 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3456 Self
3457 }
3458 }
3459 }
3460 {
3461 #[doc(hidden)]
3462 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3463 #[doc(hidden)]
3464 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3465 #[cfg(test)]
3466 #[allow(dead_code, unreachable_patterns)]
3467 fn _type_assertion(
3468 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3469 ) {
3470 match _t {
3471 alloy_sol_types::private::AssertTypeEq::<
3472 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3473 >(_) => {}
3474 }
3475 }
3476 #[automatically_derived]
3477 #[doc(hidden)]
3478 impl ::core::convert::From<INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn>
3479 for UnderlyingRustTuple<'_> {
3480 fn from(
3481 value: INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn,
3482 ) -> Self {
3483 (value._0,)
3484 }
3485 }
3486 #[automatically_derived]
3487 #[doc(hidden)]
3488 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3489 for INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn {
3490 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3491 Self { _0: tuple.0 }
3492 }
3493 }
3494 }
3495 #[automatically_derived]
3496 impl alloy_sol_types::SolCall
3497 for INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall {
3498 type Parameters<'a> = ();
3499 type Token<'a> = <Self::Parameters<
3500 'a,
3501 > as alloy_sol_types::SolType>::Token<'a>;
3502 type Return = alloy::sol_types::private::FixedBytes<4>;
3503 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3504 type ReturnToken<'a> = <Self::ReturnTuple<
3505 'a,
3506 > as alloy_sol_types::SolType>::Token<'a>;
3507 const SIGNATURE: &'static str = "INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR()";
3508 const SELECTOR: [u8; 4] = [93u8, 170u8, 158u8, 36u8];
3509 #[inline]
3510 fn new<'a>(
3511 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3512 ) -> Self {
3513 tuple.into()
3514 }
3515 #[inline]
3516 fn tokenize(&self) -> Self::Token<'_> {
3517 ()
3518 }
3519 #[inline]
3520 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3521 (
3522 <alloy::sol_types::sol_data::FixedBytes<
3523 4,
3524 > as alloy_sol_types::SolType>::tokenize(ret),
3525 )
3526 }
3527 #[inline]
3528 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3529 <Self::ReturnTuple<
3530 '_,
3531 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3532 .map(|r| {
3533 let r: INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn = r
3534 .into();
3535 r._0
3536 })
3537 }
3538 #[inline]
3539 fn abi_decode_returns_validate(
3540 data: &[u8],
3541 ) -> alloy_sol_types::Result<Self::Return> {
3542 <Self::ReturnTuple<
3543 '_,
3544 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3545 .map(|r| {
3546 let r: INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORReturn = r
3547 .into();
3548 r._0
3549 })
3550 }
3551 }
3552 };
3553 #[derive(serde::Serialize, serde::Deserialize)]
3554 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3555 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3560 #[derive(Clone)]
3561 pub struct REDEEM_TICKET_SELECTORCall;
3562 #[derive(serde::Serialize, serde::Deserialize)]
3563 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3564 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3566 #[derive(Clone)]
3567 pub struct REDEEM_TICKET_SELECTORReturn {
3568 #[allow(missing_docs)]
3569 pub _0: alloy::sol_types::private::FixedBytes<4>,
3570 }
3571 #[allow(
3572 non_camel_case_types,
3573 non_snake_case,
3574 clippy::pub_underscore_fields,
3575 clippy::style
3576 )]
3577 const _: () = {
3578 use alloy::sol_types as alloy_sol_types;
3579 {
3580 #[doc(hidden)]
3581 type UnderlyingSolTuple<'a> = ();
3582 #[doc(hidden)]
3583 type UnderlyingRustTuple<'a> = ();
3584 #[cfg(test)]
3585 #[allow(dead_code, unreachable_patterns)]
3586 fn _type_assertion(
3587 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3588 ) {
3589 match _t {
3590 alloy_sol_types::private::AssertTypeEq::<
3591 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3592 >(_) => {}
3593 }
3594 }
3595 #[automatically_derived]
3596 #[doc(hidden)]
3597 impl ::core::convert::From<REDEEM_TICKET_SELECTORCall>
3598 for UnderlyingRustTuple<'_> {
3599 fn from(value: REDEEM_TICKET_SELECTORCall) -> Self {
3600 ()
3601 }
3602 }
3603 #[automatically_derived]
3604 #[doc(hidden)]
3605 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3606 for REDEEM_TICKET_SELECTORCall {
3607 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3608 Self
3609 }
3610 }
3611 }
3612 {
3613 #[doc(hidden)]
3614 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3615 #[doc(hidden)]
3616 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3617 #[cfg(test)]
3618 #[allow(dead_code, unreachable_patterns)]
3619 fn _type_assertion(
3620 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3621 ) {
3622 match _t {
3623 alloy_sol_types::private::AssertTypeEq::<
3624 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3625 >(_) => {}
3626 }
3627 }
3628 #[automatically_derived]
3629 #[doc(hidden)]
3630 impl ::core::convert::From<REDEEM_TICKET_SELECTORReturn>
3631 for UnderlyingRustTuple<'_> {
3632 fn from(value: REDEEM_TICKET_SELECTORReturn) -> Self {
3633 (value._0,)
3634 }
3635 }
3636 #[automatically_derived]
3637 #[doc(hidden)]
3638 impl ::core::convert::From<UnderlyingRustTuple<'_>>
3639 for REDEEM_TICKET_SELECTORReturn {
3640 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3641 Self { _0: tuple.0 }
3642 }
3643 }
3644 }
3645 #[automatically_derived]
3646 impl alloy_sol_types::SolCall for REDEEM_TICKET_SELECTORCall {
3647 type Parameters<'a> = ();
3648 type Token<'a> = <Self::Parameters<
3649 'a,
3650 > as alloy_sol_types::SolType>::Token<'a>;
3651 type Return = alloy::sol_types::private::FixedBytes<4>;
3652 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3653 type ReturnToken<'a> = <Self::ReturnTuple<
3654 'a,
3655 > as alloy_sol_types::SolType>::Token<'a>;
3656 const SIGNATURE: &'static str = "REDEEM_TICKET_SELECTOR()";
3657 const SELECTOR: [u8; 4] = [81u8, 210u8, 97u8, 75u8];
3658 #[inline]
3659 fn new<'a>(
3660 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3661 ) -> Self {
3662 tuple.into()
3663 }
3664 #[inline]
3665 fn tokenize(&self) -> Self::Token<'_> {
3666 ()
3667 }
3668 #[inline]
3669 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3670 (
3671 <alloy::sol_types::sol_data::FixedBytes<
3672 4,
3673 > as alloy_sol_types::SolType>::tokenize(ret),
3674 )
3675 }
3676 #[inline]
3677 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3678 <Self::ReturnTuple<
3679 '_,
3680 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3681 .map(|r| {
3682 let r: REDEEM_TICKET_SELECTORReturn = r.into();
3683 r._0
3684 })
3685 }
3686 #[inline]
3687 fn abi_decode_returns_validate(
3688 data: &[u8],
3689 ) -> alloy_sol_types::Result<Self::Return> {
3690 <Self::ReturnTuple<
3691 '_,
3692 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3693 .map(|r| {
3694 let r: REDEEM_TICKET_SELECTORReturn = r.into();
3695 r._0
3696 })
3697 }
3698 }
3699 };
3700 #[derive(serde::Serialize, serde::Deserialize)]
3701 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3702 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3707 #[derive(Clone)]
3708 pub struct SEND_SELECTORCall;
3709 #[derive(serde::Serialize, serde::Deserialize)]
3710 #[derive(Default, Debug, PartialEq, Eq, Hash)]
3711 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
3713 #[derive(Clone)]
3714 pub struct SEND_SELECTORReturn {
3715 #[allow(missing_docs)]
3716 pub _0: alloy::sol_types::private::FixedBytes<4>,
3717 }
3718 #[allow(
3719 non_camel_case_types,
3720 non_snake_case,
3721 clippy::pub_underscore_fields,
3722 clippy::style
3723 )]
3724 const _: () = {
3725 use alloy::sol_types as alloy_sol_types;
3726 {
3727 #[doc(hidden)]
3728 type UnderlyingSolTuple<'a> = ();
3729 #[doc(hidden)]
3730 type UnderlyingRustTuple<'a> = ();
3731 #[cfg(test)]
3732 #[allow(dead_code, unreachable_patterns)]
3733 fn _type_assertion(
3734 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3735 ) {
3736 match _t {
3737 alloy_sol_types::private::AssertTypeEq::<
3738 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3739 >(_) => {}
3740 }
3741 }
3742 #[automatically_derived]
3743 #[doc(hidden)]
3744 impl ::core::convert::From<SEND_SELECTORCall> for UnderlyingRustTuple<'_> {
3745 fn from(value: SEND_SELECTORCall) -> Self {
3746 ()
3747 }
3748 }
3749 #[automatically_derived]
3750 #[doc(hidden)]
3751 impl ::core::convert::From<UnderlyingRustTuple<'_>> for SEND_SELECTORCall {
3752 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3753 Self
3754 }
3755 }
3756 }
3757 {
3758 #[doc(hidden)]
3759 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3760 #[doc(hidden)]
3761 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::FixedBytes<4>,);
3762 #[cfg(test)]
3763 #[allow(dead_code, unreachable_patterns)]
3764 fn _type_assertion(
3765 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
3766 ) {
3767 match _t {
3768 alloy_sol_types::private::AssertTypeEq::<
3769 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
3770 >(_) => {}
3771 }
3772 }
3773 #[automatically_derived]
3774 #[doc(hidden)]
3775 impl ::core::convert::From<SEND_SELECTORReturn> for UnderlyingRustTuple<'_> {
3776 fn from(value: SEND_SELECTORReturn) -> Self {
3777 (value._0,)
3778 }
3779 }
3780 #[automatically_derived]
3781 #[doc(hidden)]
3782 impl ::core::convert::From<UnderlyingRustTuple<'_>> for SEND_SELECTORReturn {
3783 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
3784 Self { _0: tuple.0 }
3785 }
3786 }
3787 }
3788 #[automatically_derived]
3789 impl alloy_sol_types::SolCall for SEND_SELECTORCall {
3790 type Parameters<'a> = ();
3791 type Token<'a> = <Self::Parameters<
3792 'a,
3793 > as alloy_sol_types::SolType>::Token<'a>;
3794 type Return = alloy::sol_types::private::FixedBytes<4>;
3795 type ReturnTuple<'a> = (alloy::sol_types::sol_data::FixedBytes<4>,);
3796 type ReturnToken<'a> = <Self::ReturnTuple<
3797 'a,
3798 > as alloy_sol_types::SolType>::Token<'a>;
3799 const SIGNATURE: &'static str = "SEND_SELECTOR()";
3800 const SELECTOR: [u8; 4] = [122u8, 117u8, 113u8, 21u8];
3801 #[inline]
3802 fn new<'a>(
3803 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
3804 ) -> Self {
3805 tuple.into()
3806 }
3807 #[inline]
3808 fn tokenize(&self) -> Self::Token<'_> {
3809 ()
3810 }
3811 #[inline]
3812 fn tokenize_returns(ret: &Self::Return) -> Self::ReturnToken<'_> {
3813 (
3814 <alloy::sol_types::sol_data::FixedBytes<
3815 4,
3816 > as alloy_sol_types::SolType>::tokenize(ret),
3817 )
3818 }
3819 #[inline]
3820 fn abi_decode_returns(data: &[u8]) -> alloy_sol_types::Result<Self::Return> {
3821 <Self::ReturnTuple<
3822 '_,
3823 > as alloy_sol_types::SolType>::abi_decode_sequence(data)
3824 .map(|r| {
3825 let r: SEND_SELECTORReturn = r.into();
3826 r._0
3827 })
3828 }
3829 #[inline]
3830 fn abi_decode_returns_validate(
3831 data: &[u8],
3832 ) -> alloy_sol_types::Result<Self::Return> {
3833 <Self::ReturnTuple<
3834 '_,
3835 > as alloy_sol_types::SolType>::abi_decode_sequence_validate(data)
3836 .map(|r| {
3837 let r: SEND_SELECTORReturn = r.into();
3838 r._0
3839 })
3840 }
3841 }
3842 };
3843 #[derive(serde::Serialize, serde::Deserialize)]
3845 #[derive()]
3846 pub enum HoprCapabilityPermissionsCalls {
3847 #[allow(missing_docs)]
3848 APPROVE_SELECTOR(APPROVE_SELECTORCall),
3849 #[allow(missing_docs)]
3850 CLOSE_INCOMING_CHANNEL_SELECTOR(CLOSE_INCOMING_CHANNEL_SELECTORCall),
3851 #[allow(missing_docs)]
3852 FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(
3853 FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall,
3854 ),
3855 #[allow(missing_docs)]
3856 FUND_CHANNEL_SELECTOR(FUND_CHANNEL_SELECTORCall),
3857 #[allow(missing_docs)]
3858 INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(
3859 INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall,
3860 ),
3861 #[allow(missing_docs)]
3862 REDEEM_TICKET_SELECTOR(REDEEM_TICKET_SELECTORCall),
3863 #[allow(missing_docs)]
3864 SEND_SELECTOR(SEND_SELECTORCall),
3865 }
3866 #[automatically_derived]
3867 impl HoprCapabilityPermissionsCalls {
3868 pub const SELECTORS: &'static [[u8; 4usize]] = &[
3875 [81u8, 210u8, 97u8, 75u8],
3876 [93u8, 170u8, 158u8, 36u8],
3877 [103u8, 138u8, 94u8, 251u8],
3878 [122u8, 117u8, 113u8, 21u8],
3879 [129u8, 103u8, 182u8, 126u8],
3880 [160u8, 134u8, 88u8, 57u8],
3881 [182u8, 119u8, 164u8, 15u8],
3882 ];
3883 }
3884 #[automatically_derived]
3885 impl alloy_sol_types::SolInterface for HoprCapabilityPermissionsCalls {
3886 const NAME: &'static str = "HoprCapabilityPermissionsCalls";
3887 const MIN_DATA_LENGTH: usize = 0usize;
3888 const COUNT: usize = 7usize;
3889 #[inline]
3890 fn selector(&self) -> [u8; 4] {
3891 match self {
3892 Self::APPROVE_SELECTOR(_) => {
3893 <APPROVE_SELECTORCall as alloy_sol_types::SolCall>::SELECTOR
3894 }
3895 Self::CLOSE_INCOMING_CHANNEL_SELECTOR(_) => {
3896 <CLOSE_INCOMING_CHANNEL_SELECTORCall as alloy_sol_types::SolCall>::SELECTOR
3897 }
3898 Self::FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(_) => {
3899 <FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall as alloy_sol_types::SolCall>::SELECTOR
3900 }
3901 Self::FUND_CHANNEL_SELECTOR(_) => {
3902 <FUND_CHANNEL_SELECTORCall as alloy_sol_types::SolCall>::SELECTOR
3903 }
3904 Self::INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(_) => {
3905 <INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall as alloy_sol_types::SolCall>::SELECTOR
3906 }
3907 Self::REDEEM_TICKET_SELECTOR(_) => {
3908 <REDEEM_TICKET_SELECTORCall as alloy_sol_types::SolCall>::SELECTOR
3909 }
3910 Self::SEND_SELECTOR(_) => {
3911 <SEND_SELECTORCall as alloy_sol_types::SolCall>::SELECTOR
3912 }
3913 }
3914 }
3915 #[inline]
3916 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
3917 Self::SELECTORS.get(i).copied()
3918 }
3919 #[inline]
3920 fn valid_selector(selector: [u8; 4]) -> bool {
3921 Self::SELECTORS.binary_search(&selector).is_ok()
3922 }
3923 #[inline]
3924 #[allow(non_snake_case)]
3925 fn abi_decode_raw(
3926 selector: [u8; 4],
3927 data: &[u8],
3928 ) -> alloy_sol_types::Result<Self> {
3929 static DECODE_SHIMS: &[fn(
3930 &[u8],
3931 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls>] = &[
3932 {
3933 fn REDEEM_TICKET_SELECTOR(
3934 data: &[u8],
3935 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
3936 <REDEEM_TICKET_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw(
3937 data,
3938 )
3939 .map(HoprCapabilityPermissionsCalls::REDEEM_TICKET_SELECTOR)
3940 }
3941 REDEEM_TICKET_SELECTOR
3942 },
3943 {
3944 fn INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(
3945 data: &[u8],
3946 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
3947 <INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw(
3948 data,
3949 )
3950 .map(
3951 HoprCapabilityPermissionsCalls::INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR,
3952 )
3953 }
3954 INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR
3955 },
3956 {
3957 fn CLOSE_INCOMING_CHANNEL_SELECTOR(
3958 data: &[u8],
3959 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
3960 <CLOSE_INCOMING_CHANNEL_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw(
3961 data,
3962 )
3963 .map(
3964 HoprCapabilityPermissionsCalls::CLOSE_INCOMING_CHANNEL_SELECTOR,
3965 )
3966 }
3967 CLOSE_INCOMING_CHANNEL_SELECTOR
3968 },
3969 {
3970 fn SEND_SELECTOR(
3971 data: &[u8],
3972 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
3973 <SEND_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw(
3974 data,
3975 )
3976 .map(HoprCapabilityPermissionsCalls::SEND_SELECTOR)
3977 }
3978 SEND_SELECTOR
3979 },
3980 {
3981 fn FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(
3982 data: &[u8],
3983 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
3984 <FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw(
3985 data,
3986 )
3987 .map(
3988 HoprCapabilityPermissionsCalls::FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR,
3989 )
3990 }
3991 FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR
3992 },
3993 {
3994 fn APPROVE_SELECTOR(
3995 data: &[u8],
3996 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
3997 <APPROVE_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw(
3998 data,
3999 )
4000 .map(HoprCapabilityPermissionsCalls::APPROVE_SELECTOR)
4001 }
4002 APPROVE_SELECTOR
4003 },
4004 {
4005 fn FUND_CHANNEL_SELECTOR(
4006 data: &[u8],
4007 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
4008 <FUND_CHANNEL_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw(
4009 data,
4010 )
4011 .map(HoprCapabilityPermissionsCalls::FUND_CHANNEL_SELECTOR)
4012 }
4013 FUND_CHANNEL_SELECTOR
4014 },
4015 ];
4016 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4017 return Err(
4018 alloy_sol_types::Error::unknown_selector(
4019 <Self as alloy_sol_types::SolInterface>::NAME,
4020 selector,
4021 ),
4022 );
4023 };
4024 DECODE_SHIMS[idx](data)
4025 }
4026 #[inline]
4027 #[allow(non_snake_case)]
4028 fn abi_decode_raw_validate(
4029 selector: [u8; 4],
4030 data: &[u8],
4031 ) -> alloy_sol_types::Result<Self> {
4032 static DECODE_VALIDATE_SHIMS: &[fn(
4033 &[u8],
4034 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls>] = &[
4035 {
4036 fn REDEEM_TICKET_SELECTOR(
4037 data: &[u8],
4038 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
4039 <REDEEM_TICKET_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4040 data,
4041 )
4042 .map(HoprCapabilityPermissionsCalls::REDEEM_TICKET_SELECTOR)
4043 }
4044 REDEEM_TICKET_SELECTOR
4045 },
4046 {
4047 fn INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(
4048 data: &[u8],
4049 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
4050 <INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4051 data,
4052 )
4053 .map(
4054 HoprCapabilityPermissionsCalls::INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR,
4055 )
4056 }
4057 INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR
4058 },
4059 {
4060 fn CLOSE_INCOMING_CHANNEL_SELECTOR(
4061 data: &[u8],
4062 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
4063 <CLOSE_INCOMING_CHANNEL_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4064 data,
4065 )
4066 .map(
4067 HoprCapabilityPermissionsCalls::CLOSE_INCOMING_CHANNEL_SELECTOR,
4068 )
4069 }
4070 CLOSE_INCOMING_CHANNEL_SELECTOR
4071 },
4072 {
4073 fn SEND_SELECTOR(
4074 data: &[u8],
4075 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
4076 <SEND_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4077 data,
4078 )
4079 .map(HoprCapabilityPermissionsCalls::SEND_SELECTOR)
4080 }
4081 SEND_SELECTOR
4082 },
4083 {
4084 fn FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(
4085 data: &[u8],
4086 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
4087 <FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4088 data,
4089 )
4090 .map(
4091 HoprCapabilityPermissionsCalls::FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR,
4092 )
4093 }
4094 FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR
4095 },
4096 {
4097 fn APPROVE_SELECTOR(
4098 data: &[u8],
4099 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
4100 <APPROVE_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4101 data,
4102 )
4103 .map(HoprCapabilityPermissionsCalls::APPROVE_SELECTOR)
4104 }
4105 APPROVE_SELECTOR
4106 },
4107 {
4108 fn FUND_CHANNEL_SELECTOR(
4109 data: &[u8],
4110 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsCalls> {
4111 <FUND_CHANNEL_SELECTORCall as alloy_sol_types::SolCall>::abi_decode_raw_validate(
4112 data,
4113 )
4114 .map(HoprCapabilityPermissionsCalls::FUND_CHANNEL_SELECTOR)
4115 }
4116 FUND_CHANNEL_SELECTOR
4117 },
4118 ];
4119 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4120 return Err(
4121 alloy_sol_types::Error::unknown_selector(
4122 <Self as alloy_sol_types::SolInterface>::NAME,
4123 selector,
4124 ),
4125 );
4126 };
4127 DECODE_VALIDATE_SHIMS[idx](data)
4128 }
4129 #[inline]
4130 fn abi_encoded_size(&self) -> usize {
4131 match self {
4132 Self::APPROVE_SELECTOR(inner) => {
4133 <APPROVE_SELECTORCall as alloy_sol_types::SolCall>::abi_encoded_size(
4134 inner,
4135 )
4136 }
4137 Self::CLOSE_INCOMING_CHANNEL_SELECTOR(inner) => {
4138 <CLOSE_INCOMING_CHANNEL_SELECTORCall as alloy_sol_types::SolCall>::abi_encoded_size(
4139 inner,
4140 )
4141 }
4142 Self::FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(inner) => {
4143 <FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall as alloy_sol_types::SolCall>::abi_encoded_size(
4144 inner,
4145 )
4146 }
4147 Self::FUND_CHANNEL_SELECTOR(inner) => {
4148 <FUND_CHANNEL_SELECTORCall as alloy_sol_types::SolCall>::abi_encoded_size(
4149 inner,
4150 )
4151 }
4152 Self::INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(inner) => {
4153 <INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall as alloy_sol_types::SolCall>::abi_encoded_size(
4154 inner,
4155 )
4156 }
4157 Self::REDEEM_TICKET_SELECTOR(inner) => {
4158 <REDEEM_TICKET_SELECTORCall as alloy_sol_types::SolCall>::abi_encoded_size(
4159 inner,
4160 )
4161 }
4162 Self::SEND_SELECTOR(inner) => {
4163 <SEND_SELECTORCall as alloy_sol_types::SolCall>::abi_encoded_size(
4164 inner,
4165 )
4166 }
4167 }
4168 }
4169 #[inline]
4170 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4171 match self {
4172 Self::APPROVE_SELECTOR(inner) => {
4173 <APPROVE_SELECTORCall as alloy_sol_types::SolCall>::abi_encode_raw(
4174 inner,
4175 out,
4176 )
4177 }
4178 Self::CLOSE_INCOMING_CHANNEL_SELECTOR(inner) => {
4179 <CLOSE_INCOMING_CHANNEL_SELECTORCall as alloy_sol_types::SolCall>::abi_encode_raw(
4180 inner,
4181 out,
4182 )
4183 }
4184 Self::FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(inner) => {
4185 <FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall as alloy_sol_types::SolCall>::abi_encode_raw(
4186 inner,
4187 out,
4188 )
4189 }
4190 Self::FUND_CHANNEL_SELECTOR(inner) => {
4191 <FUND_CHANNEL_SELECTORCall as alloy_sol_types::SolCall>::abi_encode_raw(
4192 inner,
4193 out,
4194 )
4195 }
4196 Self::INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(inner) => {
4197 <INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall as alloy_sol_types::SolCall>::abi_encode_raw(
4198 inner,
4199 out,
4200 )
4201 }
4202 Self::REDEEM_TICKET_SELECTOR(inner) => {
4203 <REDEEM_TICKET_SELECTORCall as alloy_sol_types::SolCall>::abi_encode_raw(
4204 inner,
4205 out,
4206 )
4207 }
4208 Self::SEND_SELECTOR(inner) => {
4209 <SEND_SELECTORCall as alloy_sol_types::SolCall>::abi_encode_raw(
4210 inner,
4211 out,
4212 )
4213 }
4214 }
4215 }
4216 }
4217 #[derive(serde::Serialize, serde::Deserialize)]
4219 #[derive(Debug, PartialEq, Eq, Hash)]
4220 pub enum HoprCapabilityPermissionsErrors {
4221 #[allow(missing_docs)]
4222 AddressIsZero(AddressIsZero),
4223 #[allow(missing_docs)]
4224 ArrayTooLong(ArrayTooLong),
4225 #[allow(missing_docs)]
4226 ArraysDifferentLength(ArraysDifferentLength),
4227 #[allow(missing_docs)]
4228 CalldataOutOfBounds(CalldataOutOfBounds),
4229 #[allow(missing_docs)]
4230 DefaultPermissionRejected(DefaultPermissionRejected),
4231 #[allow(missing_docs)]
4232 DelegateCallNotAllowed(DelegateCallNotAllowed),
4233 #[allow(missing_docs)]
4234 FunctionSignatureTooShort(FunctionSignatureTooShort),
4235 #[allow(missing_docs)]
4236 GranularPermissionRejected(GranularPermissionRejected),
4237 #[allow(missing_docs)]
4238 NoMembership(NoMembership),
4239 #[allow(missing_docs)]
4240 NodePermissionRejected(NodePermissionRejected),
4241 #[allow(missing_docs)]
4242 ParameterNotAllowed(ParameterNotAllowed),
4243 #[allow(missing_docs)]
4244 PermissionNotConfigured(PermissionNotConfigured),
4245 #[allow(missing_docs)]
4246 SendNotAllowed(SendNotAllowed),
4247 #[allow(missing_docs)]
4248 TargetAddressNotAllowed(TargetAddressNotAllowed),
4249 #[allow(missing_docs)]
4250 TargetIsNotScoped(TargetIsNotScoped),
4251 #[allow(missing_docs)]
4252 TargetIsScoped(TargetIsScoped),
4253 #[allow(missing_docs)]
4254 UnacceptableMultiSendOffset(UnacceptableMultiSendOffset),
4255 }
4256 #[automatically_derived]
4257 impl HoprCapabilityPermissionsErrors {
4258 pub const SELECTORS: &'static [[u8; 4usize]] = &[
4265 [9u8, 233u8, 205u8, 73u8],
4266 [13u8, 137u8, 67u8, 142u8],
4267 [49u8, 233u8, 130u8, 70u8],
4268 [70u8, 132u8, 193u8, 34u8],
4269 [70u8, 173u8, 69u8, 136u8],
4270 [74u8, 137u8, 3u8, 33u8],
4271 [88u8, 114u8, 48u8, 55u8],
4272 [110u8, 176u8, 49u8, 95u8],
4273 [116u8, 38u8, 56u8, 180u8],
4274 [116u8, 244u8, 213u8, 55u8],
4275 [126u8, 209u8, 17u8, 55u8],
4276 [134u8, 77u8, 209u8, 231u8],
4277 [134u8, 121u8, 21u8, 171u8],
4278 [189u8, 38u8, 204u8, 56u8],
4279 [232u8, 192u8, 125u8, 42u8],
4280 [239u8, 52u8, 64u8, 172u8],
4281 [253u8, 142u8, 159u8, 40u8],
4282 ];
4283 }
4284 #[automatically_derived]
4285 impl alloy_sol_types::SolInterface for HoprCapabilityPermissionsErrors {
4286 const NAME: &'static str = "HoprCapabilityPermissionsErrors";
4287 const MIN_DATA_LENGTH: usize = 0usize;
4288 const COUNT: usize = 17usize;
4289 #[inline]
4290 fn selector(&self) -> [u8; 4] {
4291 match self {
4292 Self::AddressIsZero(_) => {
4293 <AddressIsZero as alloy_sol_types::SolError>::SELECTOR
4294 }
4295 Self::ArrayTooLong(_) => {
4296 <ArrayTooLong as alloy_sol_types::SolError>::SELECTOR
4297 }
4298 Self::ArraysDifferentLength(_) => {
4299 <ArraysDifferentLength as alloy_sol_types::SolError>::SELECTOR
4300 }
4301 Self::CalldataOutOfBounds(_) => {
4302 <CalldataOutOfBounds as alloy_sol_types::SolError>::SELECTOR
4303 }
4304 Self::DefaultPermissionRejected(_) => {
4305 <DefaultPermissionRejected as alloy_sol_types::SolError>::SELECTOR
4306 }
4307 Self::DelegateCallNotAllowed(_) => {
4308 <DelegateCallNotAllowed as alloy_sol_types::SolError>::SELECTOR
4309 }
4310 Self::FunctionSignatureTooShort(_) => {
4311 <FunctionSignatureTooShort as alloy_sol_types::SolError>::SELECTOR
4312 }
4313 Self::GranularPermissionRejected(_) => {
4314 <GranularPermissionRejected as alloy_sol_types::SolError>::SELECTOR
4315 }
4316 Self::NoMembership(_) => {
4317 <NoMembership as alloy_sol_types::SolError>::SELECTOR
4318 }
4319 Self::NodePermissionRejected(_) => {
4320 <NodePermissionRejected as alloy_sol_types::SolError>::SELECTOR
4321 }
4322 Self::ParameterNotAllowed(_) => {
4323 <ParameterNotAllowed as alloy_sol_types::SolError>::SELECTOR
4324 }
4325 Self::PermissionNotConfigured(_) => {
4326 <PermissionNotConfigured as alloy_sol_types::SolError>::SELECTOR
4327 }
4328 Self::SendNotAllowed(_) => {
4329 <SendNotAllowed as alloy_sol_types::SolError>::SELECTOR
4330 }
4331 Self::TargetAddressNotAllowed(_) => {
4332 <TargetAddressNotAllowed as alloy_sol_types::SolError>::SELECTOR
4333 }
4334 Self::TargetIsNotScoped(_) => {
4335 <TargetIsNotScoped as alloy_sol_types::SolError>::SELECTOR
4336 }
4337 Self::TargetIsScoped(_) => {
4338 <TargetIsScoped as alloy_sol_types::SolError>::SELECTOR
4339 }
4340 Self::UnacceptableMultiSendOffset(_) => {
4341 <UnacceptableMultiSendOffset as alloy_sol_types::SolError>::SELECTOR
4342 }
4343 }
4344 }
4345 #[inline]
4346 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
4347 Self::SELECTORS.get(i).copied()
4348 }
4349 #[inline]
4350 fn valid_selector(selector: [u8; 4]) -> bool {
4351 Self::SELECTORS.binary_search(&selector).is_ok()
4352 }
4353 #[inline]
4354 #[allow(non_snake_case)]
4355 fn abi_decode_raw(
4356 selector: [u8; 4],
4357 data: &[u8],
4358 ) -> alloy_sol_types::Result<Self> {
4359 static DECODE_SHIMS: &[fn(
4360 &[u8],
4361 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors>] = &[
4362 {
4363 fn SendNotAllowed(
4364 data: &[u8],
4365 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4366 <SendNotAllowed as alloy_sol_types::SolError>::abi_decode_raw(
4367 data,
4368 )
4369 .map(HoprCapabilityPermissionsErrors::SendNotAllowed)
4370 }
4371 SendNotAllowed
4372 },
4373 {
4374 fn DelegateCallNotAllowed(
4375 data: &[u8],
4376 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4377 <DelegateCallNotAllowed as alloy_sol_types::SolError>::abi_decode_raw(
4378 data,
4379 )
4380 .map(HoprCapabilityPermissionsErrors::DelegateCallNotAllowed)
4381 }
4382 DelegateCallNotAllowed
4383 },
4384 {
4385 fn ParameterNotAllowed(
4386 data: &[u8],
4387 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4388 <ParameterNotAllowed as alloy_sol_types::SolError>::abi_decode_raw(
4389 data,
4390 )
4391 .map(HoprCapabilityPermissionsErrors::ParameterNotAllowed)
4392 }
4393 ParameterNotAllowed
4394 },
4395 {
4396 fn FunctionSignatureTooShort(
4397 data: &[u8],
4398 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4399 <FunctionSignatureTooShort as alloy_sol_types::SolError>::abi_decode_raw(
4400 data,
4401 )
4402 .map(
4403 HoprCapabilityPermissionsErrors::FunctionSignatureTooShort,
4404 )
4405 }
4406 FunctionSignatureTooShort
4407 },
4408 {
4409 fn PermissionNotConfigured(
4410 data: &[u8],
4411 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4412 <PermissionNotConfigured as alloy_sol_types::SolError>::abi_decode_raw(
4413 data,
4414 )
4415 .map(
4416 HoprCapabilityPermissionsErrors::PermissionNotConfigured,
4417 )
4418 }
4419 PermissionNotConfigured
4420 },
4421 {
4422 fn TargetIsNotScoped(
4423 data: &[u8],
4424 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4425 <TargetIsNotScoped as alloy_sol_types::SolError>::abi_decode_raw(
4426 data,
4427 )
4428 .map(HoprCapabilityPermissionsErrors::TargetIsNotScoped)
4429 }
4430 TargetIsNotScoped
4431 },
4432 {
4433 fn DefaultPermissionRejected(
4434 data: &[u8],
4435 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4436 <DefaultPermissionRejected as alloy_sol_types::SolError>::abi_decode_raw(
4437 data,
4438 )
4439 .map(
4440 HoprCapabilityPermissionsErrors::DefaultPermissionRejected,
4441 )
4442 }
4443 DefaultPermissionRejected
4444 },
4445 {
4446 fn NodePermissionRejected(
4447 data: &[u8],
4448 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4449 <NodePermissionRejected as alloy_sol_types::SolError>::abi_decode_raw(
4450 data,
4451 )
4452 .map(HoprCapabilityPermissionsErrors::NodePermissionRejected)
4453 }
4454 NodePermissionRejected
4455 },
4456 {
4457 fn CalldataOutOfBounds(
4458 data: &[u8],
4459 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4460 <CalldataOutOfBounds as alloy_sol_types::SolError>::abi_decode_raw(
4461 data,
4462 )
4463 .map(HoprCapabilityPermissionsErrors::CalldataOutOfBounds)
4464 }
4465 CalldataOutOfBounds
4466 },
4467 {
4468 fn ArraysDifferentLength(
4469 data: &[u8],
4470 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4471 <ArraysDifferentLength as alloy_sol_types::SolError>::abi_decode_raw(
4472 data,
4473 )
4474 .map(HoprCapabilityPermissionsErrors::ArraysDifferentLength)
4475 }
4476 ArraysDifferentLength
4477 },
4478 {
4479 fn UnacceptableMultiSendOffset(
4480 data: &[u8],
4481 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4482 <UnacceptableMultiSendOffset as alloy_sol_types::SolError>::abi_decode_raw(
4483 data,
4484 )
4485 .map(
4486 HoprCapabilityPermissionsErrors::UnacceptableMultiSendOffset,
4487 )
4488 }
4489 UnacceptableMultiSendOffset
4490 },
4491 {
4492 fn GranularPermissionRejected(
4493 data: &[u8],
4494 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4495 <GranularPermissionRejected as alloy_sol_types::SolError>::abi_decode_raw(
4496 data,
4497 )
4498 .map(
4499 HoprCapabilityPermissionsErrors::GranularPermissionRejected,
4500 )
4501 }
4502 GranularPermissionRejected
4503 },
4504 {
4505 fn AddressIsZero(
4506 data: &[u8],
4507 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4508 <AddressIsZero as alloy_sol_types::SolError>::abi_decode_raw(
4509 data,
4510 )
4511 .map(HoprCapabilityPermissionsErrors::AddressIsZero)
4512 }
4513 AddressIsZero
4514 },
4515 {
4516 fn ArrayTooLong(
4517 data: &[u8],
4518 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4519 <ArrayTooLong as alloy_sol_types::SolError>::abi_decode_raw(data)
4520 .map(HoprCapabilityPermissionsErrors::ArrayTooLong)
4521 }
4522 ArrayTooLong
4523 },
4524 {
4525 fn TargetIsScoped(
4526 data: &[u8],
4527 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4528 <TargetIsScoped as alloy_sol_types::SolError>::abi_decode_raw(
4529 data,
4530 )
4531 .map(HoprCapabilityPermissionsErrors::TargetIsScoped)
4532 }
4533 TargetIsScoped
4534 },
4535 {
4536 fn TargetAddressNotAllowed(
4537 data: &[u8],
4538 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4539 <TargetAddressNotAllowed as alloy_sol_types::SolError>::abi_decode_raw(
4540 data,
4541 )
4542 .map(
4543 HoprCapabilityPermissionsErrors::TargetAddressNotAllowed,
4544 )
4545 }
4546 TargetAddressNotAllowed
4547 },
4548 {
4549 fn NoMembership(
4550 data: &[u8],
4551 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4552 <NoMembership as alloy_sol_types::SolError>::abi_decode_raw(data)
4553 .map(HoprCapabilityPermissionsErrors::NoMembership)
4554 }
4555 NoMembership
4556 },
4557 ];
4558 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4559 return Err(
4560 alloy_sol_types::Error::unknown_selector(
4561 <Self as alloy_sol_types::SolInterface>::NAME,
4562 selector,
4563 ),
4564 );
4565 };
4566 DECODE_SHIMS[idx](data)
4567 }
4568 #[inline]
4569 #[allow(non_snake_case)]
4570 fn abi_decode_raw_validate(
4571 selector: [u8; 4],
4572 data: &[u8],
4573 ) -> alloy_sol_types::Result<Self> {
4574 static DECODE_VALIDATE_SHIMS: &[fn(
4575 &[u8],
4576 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors>] = &[
4577 {
4578 fn SendNotAllowed(
4579 data: &[u8],
4580 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4581 <SendNotAllowed as alloy_sol_types::SolError>::abi_decode_raw_validate(
4582 data,
4583 )
4584 .map(HoprCapabilityPermissionsErrors::SendNotAllowed)
4585 }
4586 SendNotAllowed
4587 },
4588 {
4589 fn DelegateCallNotAllowed(
4590 data: &[u8],
4591 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4592 <DelegateCallNotAllowed as alloy_sol_types::SolError>::abi_decode_raw_validate(
4593 data,
4594 )
4595 .map(HoprCapabilityPermissionsErrors::DelegateCallNotAllowed)
4596 }
4597 DelegateCallNotAllowed
4598 },
4599 {
4600 fn ParameterNotAllowed(
4601 data: &[u8],
4602 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4603 <ParameterNotAllowed as alloy_sol_types::SolError>::abi_decode_raw_validate(
4604 data,
4605 )
4606 .map(HoprCapabilityPermissionsErrors::ParameterNotAllowed)
4607 }
4608 ParameterNotAllowed
4609 },
4610 {
4611 fn FunctionSignatureTooShort(
4612 data: &[u8],
4613 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4614 <FunctionSignatureTooShort as alloy_sol_types::SolError>::abi_decode_raw_validate(
4615 data,
4616 )
4617 .map(
4618 HoprCapabilityPermissionsErrors::FunctionSignatureTooShort,
4619 )
4620 }
4621 FunctionSignatureTooShort
4622 },
4623 {
4624 fn PermissionNotConfigured(
4625 data: &[u8],
4626 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4627 <PermissionNotConfigured as alloy_sol_types::SolError>::abi_decode_raw_validate(
4628 data,
4629 )
4630 .map(
4631 HoprCapabilityPermissionsErrors::PermissionNotConfigured,
4632 )
4633 }
4634 PermissionNotConfigured
4635 },
4636 {
4637 fn TargetIsNotScoped(
4638 data: &[u8],
4639 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4640 <TargetIsNotScoped as alloy_sol_types::SolError>::abi_decode_raw_validate(
4641 data,
4642 )
4643 .map(HoprCapabilityPermissionsErrors::TargetIsNotScoped)
4644 }
4645 TargetIsNotScoped
4646 },
4647 {
4648 fn DefaultPermissionRejected(
4649 data: &[u8],
4650 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4651 <DefaultPermissionRejected as alloy_sol_types::SolError>::abi_decode_raw_validate(
4652 data,
4653 )
4654 .map(
4655 HoprCapabilityPermissionsErrors::DefaultPermissionRejected,
4656 )
4657 }
4658 DefaultPermissionRejected
4659 },
4660 {
4661 fn NodePermissionRejected(
4662 data: &[u8],
4663 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4664 <NodePermissionRejected as alloy_sol_types::SolError>::abi_decode_raw_validate(
4665 data,
4666 )
4667 .map(HoprCapabilityPermissionsErrors::NodePermissionRejected)
4668 }
4669 NodePermissionRejected
4670 },
4671 {
4672 fn CalldataOutOfBounds(
4673 data: &[u8],
4674 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4675 <CalldataOutOfBounds as alloy_sol_types::SolError>::abi_decode_raw_validate(
4676 data,
4677 )
4678 .map(HoprCapabilityPermissionsErrors::CalldataOutOfBounds)
4679 }
4680 CalldataOutOfBounds
4681 },
4682 {
4683 fn ArraysDifferentLength(
4684 data: &[u8],
4685 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4686 <ArraysDifferentLength as alloy_sol_types::SolError>::abi_decode_raw_validate(
4687 data,
4688 )
4689 .map(HoprCapabilityPermissionsErrors::ArraysDifferentLength)
4690 }
4691 ArraysDifferentLength
4692 },
4693 {
4694 fn UnacceptableMultiSendOffset(
4695 data: &[u8],
4696 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4697 <UnacceptableMultiSendOffset as alloy_sol_types::SolError>::abi_decode_raw_validate(
4698 data,
4699 )
4700 .map(
4701 HoprCapabilityPermissionsErrors::UnacceptableMultiSendOffset,
4702 )
4703 }
4704 UnacceptableMultiSendOffset
4705 },
4706 {
4707 fn GranularPermissionRejected(
4708 data: &[u8],
4709 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4710 <GranularPermissionRejected as alloy_sol_types::SolError>::abi_decode_raw_validate(
4711 data,
4712 )
4713 .map(
4714 HoprCapabilityPermissionsErrors::GranularPermissionRejected,
4715 )
4716 }
4717 GranularPermissionRejected
4718 },
4719 {
4720 fn AddressIsZero(
4721 data: &[u8],
4722 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4723 <AddressIsZero as alloy_sol_types::SolError>::abi_decode_raw_validate(
4724 data,
4725 )
4726 .map(HoprCapabilityPermissionsErrors::AddressIsZero)
4727 }
4728 AddressIsZero
4729 },
4730 {
4731 fn ArrayTooLong(
4732 data: &[u8],
4733 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4734 <ArrayTooLong as alloy_sol_types::SolError>::abi_decode_raw_validate(
4735 data,
4736 )
4737 .map(HoprCapabilityPermissionsErrors::ArrayTooLong)
4738 }
4739 ArrayTooLong
4740 },
4741 {
4742 fn TargetIsScoped(
4743 data: &[u8],
4744 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4745 <TargetIsScoped as alloy_sol_types::SolError>::abi_decode_raw_validate(
4746 data,
4747 )
4748 .map(HoprCapabilityPermissionsErrors::TargetIsScoped)
4749 }
4750 TargetIsScoped
4751 },
4752 {
4753 fn TargetAddressNotAllowed(
4754 data: &[u8],
4755 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4756 <TargetAddressNotAllowed as alloy_sol_types::SolError>::abi_decode_raw_validate(
4757 data,
4758 )
4759 .map(
4760 HoprCapabilityPermissionsErrors::TargetAddressNotAllowed,
4761 )
4762 }
4763 TargetAddressNotAllowed
4764 },
4765 {
4766 fn NoMembership(
4767 data: &[u8],
4768 ) -> alloy_sol_types::Result<HoprCapabilityPermissionsErrors> {
4769 <NoMembership as alloy_sol_types::SolError>::abi_decode_raw_validate(
4770 data,
4771 )
4772 .map(HoprCapabilityPermissionsErrors::NoMembership)
4773 }
4774 NoMembership
4775 },
4776 ];
4777 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
4778 return Err(
4779 alloy_sol_types::Error::unknown_selector(
4780 <Self as alloy_sol_types::SolInterface>::NAME,
4781 selector,
4782 ),
4783 );
4784 };
4785 DECODE_VALIDATE_SHIMS[idx](data)
4786 }
4787 #[inline]
4788 fn abi_encoded_size(&self) -> usize {
4789 match self {
4790 Self::AddressIsZero(inner) => {
4791 <AddressIsZero as alloy_sol_types::SolError>::abi_encoded_size(inner)
4792 }
4793 Self::ArrayTooLong(inner) => {
4794 <ArrayTooLong as alloy_sol_types::SolError>::abi_encoded_size(inner)
4795 }
4796 Self::ArraysDifferentLength(inner) => {
4797 <ArraysDifferentLength as alloy_sol_types::SolError>::abi_encoded_size(
4798 inner,
4799 )
4800 }
4801 Self::CalldataOutOfBounds(inner) => {
4802 <CalldataOutOfBounds as alloy_sol_types::SolError>::abi_encoded_size(
4803 inner,
4804 )
4805 }
4806 Self::DefaultPermissionRejected(inner) => {
4807 <DefaultPermissionRejected as alloy_sol_types::SolError>::abi_encoded_size(
4808 inner,
4809 )
4810 }
4811 Self::DelegateCallNotAllowed(inner) => {
4812 <DelegateCallNotAllowed as alloy_sol_types::SolError>::abi_encoded_size(
4813 inner,
4814 )
4815 }
4816 Self::FunctionSignatureTooShort(inner) => {
4817 <FunctionSignatureTooShort as alloy_sol_types::SolError>::abi_encoded_size(
4818 inner,
4819 )
4820 }
4821 Self::GranularPermissionRejected(inner) => {
4822 <GranularPermissionRejected as alloy_sol_types::SolError>::abi_encoded_size(
4823 inner,
4824 )
4825 }
4826 Self::NoMembership(inner) => {
4827 <NoMembership as alloy_sol_types::SolError>::abi_encoded_size(inner)
4828 }
4829 Self::NodePermissionRejected(inner) => {
4830 <NodePermissionRejected as alloy_sol_types::SolError>::abi_encoded_size(
4831 inner,
4832 )
4833 }
4834 Self::ParameterNotAllowed(inner) => {
4835 <ParameterNotAllowed as alloy_sol_types::SolError>::abi_encoded_size(
4836 inner,
4837 )
4838 }
4839 Self::PermissionNotConfigured(inner) => {
4840 <PermissionNotConfigured as alloy_sol_types::SolError>::abi_encoded_size(
4841 inner,
4842 )
4843 }
4844 Self::SendNotAllowed(inner) => {
4845 <SendNotAllowed as alloy_sol_types::SolError>::abi_encoded_size(
4846 inner,
4847 )
4848 }
4849 Self::TargetAddressNotAllowed(inner) => {
4850 <TargetAddressNotAllowed as alloy_sol_types::SolError>::abi_encoded_size(
4851 inner,
4852 )
4853 }
4854 Self::TargetIsNotScoped(inner) => {
4855 <TargetIsNotScoped as alloy_sol_types::SolError>::abi_encoded_size(
4856 inner,
4857 )
4858 }
4859 Self::TargetIsScoped(inner) => {
4860 <TargetIsScoped as alloy_sol_types::SolError>::abi_encoded_size(
4861 inner,
4862 )
4863 }
4864 Self::UnacceptableMultiSendOffset(inner) => {
4865 <UnacceptableMultiSendOffset as alloy_sol_types::SolError>::abi_encoded_size(
4866 inner,
4867 )
4868 }
4869 }
4870 }
4871 #[inline]
4872 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
4873 match self {
4874 Self::AddressIsZero(inner) => {
4875 <AddressIsZero as alloy_sol_types::SolError>::abi_encode_raw(
4876 inner,
4877 out,
4878 )
4879 }
4880 Self::ArrayTooLong(inner) => {
4881 <ArrayTooLong as alloy_sol_types::SolError>::abi_encode_raw(
4882 inner,
4883 out,
4884 )
4885 }
4886 Self::ArraysDifferentLength(inner) => {
4887 <ArraysDifferentLength as alloy_sol_types::SolError>::abi_encode_raw(
4888 inner,
4889 out,
4890 )
4891 }
4892 Self::CalldataOutOfBounds(inner) => {
4893 <CalldataOutOfBounds as alloy_sol_types::SolError>::abi_encode_raw(
4894 inner,
4895 out,
4896 )
4897 }
4898 Self::DefaultPermissionRejected(inner) => {
4899 <DefaultPermissionRejected as alloy_sol_types::SolError>::abi_encode_raw(
4900 inner,
4901 out,
4902 )
4903 }
4904 Self::DelegateCallNotAllowed(inner) => {
4905 <DelegateCallNotAllowed as alloy_sol_types::SolError>::abi_encode_raw(
4906 inner,
4907 out,
4908 )
4909 }
4910 Self::FunctionSignatureTooShort(inner) => {
4911 <FunctionSignatureTooShort as alloy_sol_types::SolError>::abi_encode_raw(
4912 inner,
4913 out,
4914 )
4915 }
4916 Self::GranularPermissionRejected(inner) => {
4917 <GranularPermissionRejected as alloy_sol_types::SolError>::abi_encode_raw(
4918 inner,
4919 out,
4920 )
4921 }
4922 Self::NoMembership(inner) => {
4923 <NoMembership as alloy_sol_types::SolError>::abi_encode_raw(
4924 inner,
4925 out,
4926 )
4927 }
4928 Self::NodePermissionRejected(inner) => {
4929 <NodePermissionRejected as alloy_sol_types::SolError>::abi_encode_raw(
4930 inner,
4931 out,
4932 )
4933 }
4934 Self::ParameterNotAllowed(inner) => {
4935 <ParameterNotAllowed as alloy_sol_types::SolError>::abi_encode_raw(
4936 inner,
4937 out,
4938 )
4939 }
4940 Self::PermissionNotConfigured(inner) => {
4941 <PermissionNotConfigured as alloy_sol_types::SolError>::abi_encode_raw(
4942 inner,
4943 out,
4944 )
4945 }
4946 Self::SendNotAllowed(inner) => {
4947 <SendNotAllowed as alloy_sol_types::SolError>::abi_encode_raw(
4948 inner,
4949 out,
4950 )
4951 }
4952 Self::TargetAddressNotAllowed(inner) => {
4953 <TargetAddressNotAllowed as alloy_sol_types::SolError>::abi_encode_raw(
4954 inner,
4955 out,
4956 )
4957 }
4958 Self::TargetIsNotScoped(inner) => {
4959 <TargetIsNotScoped as alloy_sol_types::SolError>::abi_encode_raw(
4960 inner,
4961 out,
4962 )
4963 }
4964 Self::TargetIsScoped(inner) => {
4965 <TargetIsScoped as alloy_sol_types::SolError>::abi_encode_raw(
4966 inner,
4967 out,
4968 )
4969 }
4970 Self::UnacceptableMultiSendOffset(inner) => {
4971 <UnacceptableMultiSendOffset as alloy_sol_types::SolError>::abi_encode_raw(
4972 inner,
4973 out,
4974 )
4975 }
4976 }
4977 }
4978 }
4979 #[derive(serde::Serialize, serde::Deserialize)]
4981 #[derive(Debug, PartialEq, Eq, Hash)]
4982 pub enum HoprCapabilityPermissionsEvents {
4983 #[allow(missing_docs)]
4984 RevokedTarget(RevokedTarget),
4985 #[allow(missing_docs)]
4986 ScopedGranularChannelCapability(ScopedGranularChannelCapability),
4987 #[allow(missing_docs)]
4988 ScopedGranularSendCapability(ScopedGranularSendCapability),
4989 #[allow(missing_docs)]
4990 ScopedGranularTokenCapability(ScopedGranularTokenCapability),
4991 #[allow(missing_docs)]
4992 ScopedTargetChannels(ScopedTargetChannels),
4993 #[allow(missing_docs)]
4994 ScopedTargetSend(ScopedTargetSend),
4995 #[allow(missing_docs)]
4996 ScopedTargetToken(ScopedTargetToken),
4997 }
4998 #[automatically_derived]
4999 impl HoprCapabilityPermissionsEvents {
5000 pub const SELECTORS: &'static [[u8; 32usize]] = &[
5007 [
5008 13u8, 252u8, 225u8, 234u8, 75u8, 161u8, 238u8, 186u8, 137u8, 31u8, 251u8,
5009 42u8, 6u8, 103u8, 144u8, 251u8, 194u8, 147u8, 169u8, 229u8, 23u8, 254u8,
5010 97u8, 212u8, 157u8, 21u8, 106u8, 48u8, 22u8, 95u8, 147u8, 243u8,
5011 ],
5012 [
5013 30u8, 226u8, 121u8, 31u8, 44u8, 175u8, 14u8, 146u8, 169u8, 220u8, 50u8,
5014 163u8, 122u8, 158u8, 165u8, 58u8, 182u8, 172u8, 122u8, 111u8, 184u8,
5015 242u8, 208u8, 144u8, 229u8, 58u8, 6u8, 125u8, 58u8, 67u8, 246u8, 172u8,
5016 ],
5017 [
5018 95u8, 251u8, 6u8, 176u8, 176u8, 232u8, 173u8, 106u8, 143u8, 60u8, 88u8,
5019 49u8, 212u8, 153u8, 223u8, 166u8, 18u8, 217u8, 201u8, 212u8, 220u8, 16u8,
5020 123u8, 189u8, 102u8, 241u8, 143u8, 97u8, 166u8, 73u8, 46u8, 113u8,
5021 ],
5022 [
5023 116u8, 135u8, 83u8, 13u8, 223u8, 241u8, 32u8, 121u8, 149u8, 5u8, 229u8,
5024 43u8, 27u8, 25u8, 182u8, 147u8, 63u8, 133u8, 169u8, 238u8, 174u8, 146u8,
5025 32u8, 200u8, 10u8, 122u8, 215u8, 196u8, 41u8, 182u8, 18u8, 174u8,
5026 ],
5027 [
5028 163u8, 223u8, 113u8, 4u8, 32u8, 176u8, 28u8, 195u8, 15u8, 243u8, 0u8,
5029 48u8, 154u8, 187u8, 199u8, 250u8, 221u8, 70u8, 48u8, 212u8, 171u8, 56u8,
5030 91u8, 15u8, 90u8, 18u8, 111u8, 180u8, 186u8, 190u8, 118u8, 43u8,
5031 ],
5032 [
5033 170u8, 242u8, 107u8, 177u8, 42u8, 168u8, 158u8, 233u8, 107u8, 190u8,
5034 25u8, 102u8, 122u8, 106u8, 5u8, 87u8, 39u8, 183u8, 93u8, 63u8, 110u8,
5035 215u8, 184u8, 182u8, 17u8, 239u8, 101u8, 25u8, 24u8, 2u8, 9u8, 214u8,
5036 ],
5037 [
5038 242u8, 255u8, 212u8, 240u8, 157u8, 88u8, 208u8, 104u8, 36u8, 24u8, 128u8,
5039 51u8, 211u8, 49u8, 141u8, 6u8, 235u8, 149u8, 123u8, 251u8, 26u8, 143u8,
5040 254u8, 217u8, 175u8, 120u8, 225u8, 241u8, 145u8, 104u8, 185u8, 4u8,
5041 ],
5042 ];
5043 }
5044 #[automatically_derived]
5045 impl alloy_sol_types::SolEventInterface for HoprCapabilityPermissionsEvents {
5046 const NAME: &'static str = "HoprCapabilityPermissionsEvents";
5047 const COUNT: usize = 7usize;
5048 fn decode_raw_log(
5049 topics: &[alloy_sol_types::Word],
5050 data: &[u8],
5051 ) -> alloy_sol_types::Result<Self> {
5052 match topics.first().copied() {
5053 Some(<RevokedTarget as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5054 <RevokedTarget as alloy_sol_types::SolEvent>::decode_raw_log(
5055 topics,
5056 data,
5057 )
5058 .map(Self::RevokedTarget)
5059 }
5060 Some(
5061 <ScopedGranularChannelCapability as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5062 ) => {
5063 <ScopedGranularChannelCapability as alloy_sol_types::SolEvent>::decode_raw_log(
5064 topics,
5065 data,
5066 )
5067 .map(Self::ScopedGranularChannelCapability)
5068 }
5069 Some(
5070 <ScopedGranularSendCapability as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5071 ) => {
5072 <ScopedGranularSendCapability as alloy_sol_types::SolEvent>::decode_raw_log(
5073 topics,
5074 data,
5075 )
5076 .map(Self::ScopedGranularSendCapability)
5077 }
5078 Some(
5079 <ScopedGranularTokenCapability as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5080 ) => {
5081 <ScopedGranularTokenCapability as alloy_sol_types::SolEvent>::decode_raw_log(
5082 topics,
5083 data,
5084 )
5085 .map(Self::ScopedGranularTokenCapability)
5086 }
5087 Some(
5088 <ScopedTargetChannels as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5089 ) => {
5090 <ScopedTargetChannels as alloy_sol_types::SolEvent>::decode_raw_log(
5091 topics,
5092 data,
5093 )
5094 .map(Self::ScopedTargetChannels)
5095 }
5096 Some(<ScopedTargetSend as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
5097 <ScopedTargetSend as alloy_sol_types::SolEvent>::decode_raw_log(
5098 topics,
5099 data,
5100 )
5101 .map(Self::ScopedTargetSend)
5102 }
5103 Some(
5104 <ScopedTargetToken as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
5105 ) => {
5106 <ScopedTargetToken as alloy_sol_types::SolEvent>::decode_raw_log(
5107 topics,
5108 data,
5109 )
5110 .map(Self::ScopedTargetToken)
5111 }
5112 _ => {
5113 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
5114 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
5115 log: alloy_sol_types::private::Box::new(
5116 alloy_sol_types::private::LogData::new_unchecked(
5117 topics.to_vec(),
5118 data.to_vec().into(),
5119 ),
5120 ),
5121 })
5122 }
5123 }
5124 }
5125 }
5126 #[automatically_derived]
5127 impl alloy_sol_types::private::IntoLogData for HoprCapabilityPermissionsEvents {
5128 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
5129 match self {
5130 Self::RevokedTarget(inner) => {
5131 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5132 }
5133 Self::ScopedGranularChannelCapability(inner) => {
5134 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5135 }
5136 Self::ScopedGranularSendCapability(inner) => {
5137 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5138 }
5139 Self::ScopedGranularTokenCapability(inner) => {
5140 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5141 }
5142 Self::ScopedTargetChannels(inner) => {
5143 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5144 }
5145 Self::ScopedTargetSend(inner) => {
5146 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5147 }
5148 Self::ScopedTargetToken(inner) => {
5149 alloy_sol_types::private::IntoLogData::to_log_data(inner)
5150 }
5151 }
5152 }
5153 fn into_log_data(self) -> alloy_sol_types::private::LogData {
5154 match self {
5155 Self::RevokedTarget(inner) => {
5156 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5157 }
5158 Self::ScopedGranularChannelCapability(inner) => {
5159 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5160 }
5161 Self::ScopedGranularSendCapability(inner) => {
5162 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5163 }
5164 Self::ScopedGranularTokenCapability(inner) => {
5165 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5166 }
5167 Self::ScopedTargetChannels(inner) => {
5168 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5169 }
5170 Self::ScopedTargetSend(inner) => {
5171 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5172 }
5173 Self::ScopedTargetToken(inner) => {
5174 alloy_sol_types::private::IntoLogData::into_log_data(inner)
5175 }
5176 }
5177 }
5178 }
5179 use alloy::contract as alloy_contract;
5180 #[inline]
5184 pub const fn new<
5185 P: alloy_contract::private::Provider<N>,
5186 N: alloy_contract::private::Network,
5187 >(
5188 address: alloy_sol_types::private::Address,
5189 provider: P,
5190 ) -> HoprCapabilityPermissionsInstance<P, N> {
5191 HoprCapabilityPermissionsInstance::<P, N>::new(address, provider)
5192 }
5193 #[inline]
5199 pub fn deploy<
5200 P: alloy_contract::private::Provider<N>,
5201 N: alloy_contract::private::Network,
5202 >(
5203 provider: P,
5204 ) -> impl ::core::future::Future<
5205 Output = alloy_contract::Result<HoprCapabilityPermissionsInstance<P, N>>,
5206 > {
5207 HoprCapabilityPermissionsInstance::<P, N>::deploy(provider)
5208 }
5209 #[inline]
5215 pub fn deploy_builder<
5216 P: alloy_contract::private::Provider<N>,
5217 N: alloy_contract::private::Network,
5218 >(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
5219 HoprCapabilityPermissionsInstance::<P, N>::deploy_builder(provider)
5220 }
5221 #[derive(Clone)]
5233 pub struct HoprCapabilityPermissionsInstance<
5234 P,
5235 N = alloy_contract::private::Ethereum,
5236 > {
5237 address: alloy_sol_types::private::Address,
5238 provider: P,
5239 _network: ::core::marker::PhantomData<N>,
5240 }
5241 #[automatically_derived]
5242 impl<P, N> ::core::fmt::Debug for HoprCapabilityPermissionsInstance<P, N> {
5243 #[inline]
5244 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
5245 f.debug_tuple("HoprCapabilityPermissionsInstance")
5246 .field(&self.address)
5247 .finish()
5248 }
5249 }
5250 #[automatically_derived]
5252 impl<
5253 P: alloy_contract::private::Provider<N>,
5254 N: alloy_contract::private::Network,
5255 > HoprCapabilityPermissionsInstance<P, N> {
5256 #[inline]
5260 pub const fn new(
5261 address: alloy_sol_types::private::Address,
5262 provider: P,
5263 ) -> Self {
5264 Self {
5265 address,
5266 provider,
5267 _network: ::core::marker::PhantomData,
5268 }
5269 }
5270 #[inline]
5276 pub async fn deploy(
5277 provider: P,
5278 ) -> alloy_contract::Result<HoprCapabilityPermissionsInstance<P, N>> {
5279 let call_builder = Self::deploy_builder(provider);
5280 let contract_address = call_builder.deploy().await?;
5281 Ok(Self::new(contract_address, call_builder.provider))
5282 }
5283 #[inline]
5289 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<P, N> {
5290 alloy_contract::RawCallBuilder::new_raw_deploy(
5291 provider,
5292 ::core::clone::Clone::clone(&BYTECODE),
5293 )
5294 }
5295 #[inline]
5297 pub const fn address(&self) -> &alloy_sol_types::private::Address {
5298 &self.address
5299 }
5300 #[inline]
5302 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
5303 self.address = address;
5304 }
5305 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
5307 self.set_address(address);
5308 self
5309 }
5310 #[inline]
5312 pub const fn provider(&self) -> &P {
5313 &self.provider
5314 }
5315 }
5316 impl<P: ::core::clone::Clone, N> HoprCapabilityPermissionsInstance<&P, N> {
5317 #[inline]
5319 pub fn with_cloned_provider(self) -> HoprCapabilityPermissionsInstance<P, N> {
5320 HoprCapabilityPermissionsInstance {
5321 address: self.address,
5322 provider: ::core::clone::Clone::clone(&self.provider),
5323 _network: ::core::marker::PhantomData,
5324 }
5325 }
5326 }
5327 #[automatically_derived]
5329 impl<
5330 P: alloy_contract::private::Provider<N>,
5331 N: alloy_contract::private::Network,
5332 > HoprCapabilityPermissionsInstance<P, N> {
5333 pub fn call_builder<C: alloy_sol_types::SolCall>(
5338 &self,
5339 call: &C,
5340 ) -> alloy_contract::SolCallBuilder<&P, C, N> {
5341 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
5342 }
5343 pub fn APPROVE_SELECTOR(
5345 &self,
5346 ) -> alloy_contract::SolCallBuilder<&P, APPROVE_SELECTORCall, N> {
5347 self.call_builder(&APPROVE_SELECTORCall)
5348 }
5349 pub fn CLOSE_INCOMING_CHANNEL_SELECTOR(
5351 &self,
5352 ) -> alloy_contract::SolCallBuilder<&P, CLOSE_INCOMING_CHANNEL_SELECTORCall, N> {
5353 self.call_builder(&CLOSE_INCOMING_CHANNEL_SELECTORCall)
5354 }
5355 pub fn FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(
5357 &self,
5358 ) -> alloy_contract::SolCallBuilder<
5359 &P,
5360 FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall,
5361 N,
5362 > {
5363 self.call_builder(&FINALIZE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall)
5364 }
5365 pub fn FUND_CHANNEL_SELECTOR(
5367 &self,
5368 ) -> alloy_contract::SolCallBuilder<&P, FUND_CHANNEL_SELECTORCall, N> {
5369 self.call_builder(&FUND_CHANNEL_SELECTORCall)
5370 }
5371 pub fn INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTOR(
5373 &self,
5374 ) -> alloy_contract::SolCallBuilder<
5375 &P,
5376 INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall,
5377 N,
5378 > {
5379 self.call_builder(&INITIATE_OUTGOING_CHANNEL_CLOSURE_SELECTORCall)
5380 }
5381 pub fn REDEEM_TICKET_SELECTOR(
5383 &self,
5384 ) -> alloy_contract::SolCallBuilder<&P, REDEEM_TICKET_SELECTORCall, N> {
5385 self.call_builder(&REDEEM_TICKET_SELECTORCall)
5386 }
5387 pub fn SEND_SELECTOR(
5389 &self,
5390 ) -> alloy_contract::SolCallBuilder<&P, SEND_SELECTORCall, N> {
5391 self.call_builder(&SEND_SELECTORCall)
5392 }
5393 }
5394 #[automatically_derived]
5396 impl<
5397 P: alloy_contract::private::Provider<N>,
5398 N: alloy_contract::private::Network,
5399 > HoprCapabilityPermissionsInstance<P, N> {
5400 pub fn event_filter<E: alloy_sol_types::SolEvent>(
5405 &self,
5406 ) -> alloy_contract::Event<&P, E, N> {
5407 alloy_contract::Event::new_sol(&self.provider, &self.address)
5408 }
5409 pub fn RevokedTarget_filter(
5411 &self,
5412 ) -> alloy_contract::Event<&P, RevokedTarget, N> {
5413 self.event_filter::<RevokedTarget>()
5414 }
5415 pub fn ScopedGranularChannelCapability_filter(
5417 &self,
5418 ) -> alloy_contract::Event<&P, ScopedGranularChannelCapability, N> {
5419 self.event_filter::<ScopedGranularChannelCapability>()
5420 }
5421 pub fn ScopedGranularSendCapability_filter(
5423 &self,
5424 ) -> alloy_contract::Event<&P, ScopedGranularSendCapability, N> {
5425 self.event_filter::<ScopedGranularSendCapability>()
5426 }
5427 pub fn ScopedGranularTokenCapability_filter(
5429 &self,
5430 ) -> alloy_contract::Event<&P, ScopedGranularTokenCapability, N> {
5431 self.event_filter::<ScopedGranularTokenCapability>()
5432 }
5433 pub fn ScopedTargetChannels_filter(
5435 &self,
5436 ) -> alloy_contract::Event<&P, ScopedTargetChannels, N> {
5437 self.event_filter::<ScopedTargetChannels>()
5438 }
5439 pub fn ScopedTargetSend_filter(
5441 &self,
5442 ) -> alloy_contract::Event<&P, ScopedTargetSend, N> {
5443 self.event_filter::<ScopedTargetSend>()
5444 }
5445 pub fn ScopedTargetToken_filter(
5447 &self,
5448 ) -> alloy_contract::Event<&P, ScopedTargetToken, N> {
5449 self.event_filter::<ScopedTargetToken>()
5450 }
5451 }
5452}