1#![allow(clippy::all, clippy::pedantic, clippy::nursery, warnings, unknown_lints, rustdoc::all, elided_lifetimes_in_paths)]
2use IStrategy::*;
3
4#[allow(
341 non_camel_case_types,
342 non_snake_case,
343 clippy::pub_underscore_fields,
344 clippy::style,
345 clippy::empty_structs_with_brackets
346)]
347pub mod IStrategy {
348 use super::*;
349 use alloy::sol_types as alloy_sol_types;
350 #[rustfmt::skip]
356 #[allow(clippy::all)]
357 pub static BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
358 b"",
359 );
360 #[rustfmt::skip]
366 #[allow(clippy::all)]
367 pub static DEPLOYED_BYTECODE: alloy_sol_types::private::Bytes = alloy_sol_types::private::Bytes::from_static(
368 b"",
369 );
370 #[derive(Default, Debug, PartialEq, Eq, Hash)]
371 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
376 #[derive(Clone)]
377 pub struct BalanceExceedsMaxTotalDeposits {}
378 #[allow(
379 non_camel_case_types,
380 non_snake_case,
381 clippy::pub_underscore_fields,
382 clippy::style
383 )]
384 const _: () = {
385 use alloy::sol_types as alloy_sol_types;
386 #[doc(hidden)]
387 type UnderlyingSolTuple<'a> = ();
388 #[doc(hidden)]
389 type UnderlyingRustTuple<'a> = ();
390 #[cfg(test)]
391 #[allow(dead_code, unreachable_patterns)]
392 fn _type_assertion(
393 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
394 ) {
395 match _t {
396 alloy_sol_types::private::AssertTypeEq::<
397 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
398 >(_) => {}
399 }
400 }
401 #[automatically_derived]
402 #[doc(hidden)]
403 impl ::core::convert::From<BalanceExceedsMaxTotalDeposits>
404 for UnderlyingRustTuple<'_> {
405 fn from(value: BalanceExceedsMaxTotalDeposits) -> Self {
406 ()
407 }
408 }
409 #[automatically_derived]
410 #[doc(hidden)]
411 impl ::core::convert::From<UnderlyingRustTuple<'_>>
412 for BalanceExceedsMaxTotalDeposits {
413 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
414 Self {}
415 }
416 }
417 #[automatically_derived]
418 impl alloy_sol_types::SolError for BalanceExceedsMaxTotalDeposits {
419 type Parameters<'a> = UnderlyingSolTuple<'a>;
420 type Token<'a> = <Self::Parameters<
421 'a,
422 > as alloy_sol_types::SolType>::Token<'a>;
423 const SIGNATURE: &'static str = "BalanceExceedsMaxTotalDeposits()";
424 const SELECTOR: [u8; 4] = [216u8, 107u8, 174u8, 103u8];
425 #[inline]
426 fn new<'a>(
427 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
428 ) -> Self {
429 tuple.into()
430 }
431 #[inline]
432 fn tokenize(&self) -> Self::Token<'_> {
433 ()
434 }
435 }
436 };
437 #[derive(Default, Debug, PartialEq, Eq, Hash)]
438 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
443 #[derive(Clone)]
444 pub struct MaxPerDepositExceedsMax {}
445 #[allow(
446 non_camel_case_types,
447 non_snake_case,
448 clippy::pub_underscore_fields,
449 clippy::style
450 )]
451 const _: () = {
452 use alloy::sol_types as alloy_sol_types;
453 #[doc(hidden)]
454 type UnderlyingSolTuple<'a> = ();
455 #[doc(hidden)]
456 type UnderlyingRustTuple<'a> = ();
457 #[cfg(test)]
458 #[allow(dead_code, unreachable_patterns)]
459 fn _type_assertion(
460 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
461 ) {
462 match _t {
463 alloy_sol_types::private::AssertTypeEq::<
464 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
465 >(_) => {}
466 }
467 }
468 #[automatically_derived]
469 #[doc(hidden)]
470 impl ::core::convert::From<MaxPerDepositExceedsMax> for UnderlyingRustTuple<'_> {
471 fn from(value: MaxPerDepositExceedsMax) -> Self {
472 ()
473 }
474 }
475 #[automatically_derived]
476 #[doc(hidden)]
477 impl ::core::convert::From<UnderlyingRustTuple<'_>> for MaxPerDepositExceedsMax {
478 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
479 Self {}
480 }
481 }
482 #[automatically_derived]
483 impl alloy_sol_types::SolError for MaxPerDepositExceedsMax {
484 type Parameters<'a> = UnderlyingSolTuple<'a>;
485 type Token<'a> = <Self::Parameters<
486 'a,
487 > as alloy_sol_types::SolType>::Token<'a>;
488 const SIGNATURE: &'static str = "MaxPerDepositExceedsMax()";
489 const SELECTOR: [u8; 4] = [20u8, 172u8, 30u8, 220u8];
490 #[inline]
491 fn new<'a>(
492 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
493 ) -> Self {
494 tuple.into()
495 }
496 #[inline]
497 fn tokenize(&self) -> Self::Token<'_> {
498 ()
499 }
500 }
501 };
502 #[derive(Default, Debug, PartialEq, Eq, Hash)]
503 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
508 #[derive(Clone)]
509 pub struct NewSharesZero {}
510 #[allow(
511 non_camel_case_types,
512 non_snake_case,
513 clippy::pub_underscore_fields,
514 clippy::style
515 )]
516 const _: () = {
517 use alloy::sol_types as alloy_sol_types;
518 #[doc(hidden)]
519 type UnderlyingSolTuple<'a> = ();
520 #[doc(hidden)]
521 type UnderlyingRustTuple<'a> = ();
522 #[cfg(test)]
523 #[allow(dead_code, unreachable_patterns)]
524 fn _type_assertion(
525 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
526 ) {
527 match _t {
528 alloy_sol_types::private::AssertTypeEq::<
529 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
530 >(_) => {}
531 }
532 }
533 #[automatically_derived]
534 #[doc(hidden)]
535 impl ::core::convert::From<NewSharesZero> for UnderlyingRustTuple<'_> {
536 fn from(value: NewSharesZero) -> Self {
537 ()
538 }
539 }
540 #[automatically_derived]
541 #[doc(hidden)]
542 impl ::core::convert::From<UnderlyingRustTuple<'_>> for NewSharesZero {
543 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
544 Self {}
545 }
546 }
547 #[automatically_derived]
548 impl alloy_sol_types::SolError for NewSharesZero {
549 type Parameters<'a> = UnderlyingSolTuple<'a>;
550 type Token<'a> = <Self::Parameters<
551 'a,
552 > as alloy_sol_types::SolType>::Token<'a>;
553 const SIGNATURE: &'static str = "NewSharesZero()";
554 const SELECTOR: [u8; 4] = [24u8, 114u8, 93u8, 166u8];
555 #[inline]
556 fn new<'a>(
557 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
558 ) -> Self {
559 tuple.into()
560 }
561 #[inline]
562 fn tokenize(&self) -> Self::Token<'_> {
563 ()
564 }
565 }
566 };
567 #[derive(Default, Debug, PartialEq, Eq, Hash)]
568 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
573 #[derive(Clone)]
574 pub struct OnlyStrategyManager {}
575 #[allow(
576 non_camel_case_types,
577 non_snake_case,
578 clippy::pub_underscore_fields,
579 clippy::style
580 )]
581 const _: () = {
582 use alloy::sol_types as alloy_sol_types;
583 #[doc(hidden)]
584 type UnderlyingSolTuple<'a> = ();
585 #[doc(hidden)]
586 type UnderlyingRustTuple<'a> = ();
587 #[cfg(test)]
588 #[allow(dead_code, unreachable_patterns)]
589 fn _type_assertion(
590 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
591 ) {
592 match _t {
593 alloy_sol_types::private::AssertTypeEq::<
594 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
595 >(_) => {}
596 }
597 }
598 #[automatically_derived]
599 #[doc(hidden)]
600 impl ::core::convert::From<OnlyStrategyManager> for UnderlyingRustTuple<'_> {
601 fn from(value: OnlyStrategyManager) -> Self {
602 ()
603 }
604 }
605 #[automatically_derived]
606 #[doc(hidden)]
607 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyStrategyManager {
608 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
609 Self {}
610 }
611 }
612 #[automatically_derived]
613 impl alloy_sol_types::SolError for OnlyStrategyManager {
614 type Parameters<'a> = UnderlyingSolTuple<'a>;
615 type Token<'a> = <Self::Parameters<
616 'a,
617 > as alloy_sol_types::SolType>::Token<'a>;
618 const SIGNATURE: &'static str = "OnlyStrategyManager()";
619 const SELECTOR: [u8; 4] = [72u8, 218u8, 113u8, 79u8];
620 #[inline]
621 fn new<'a>(
622 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
623 ) -> Self {
624 tuple.into()
625 }
626 #[inline]
627 fn tokenize(&self) -> Self::Token<'_> {
628 ()
629 }
630 }
631 };
632 #[derive(Default, Debug, PartialEq, Eq, Hash)]
633 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
638 #[derive(Clone)]
639 pub struct OnlyUnderlyingToken {}
640 #[allow(
641 non_camel_case_types,
642 non_snake_case,
643 clippy::pub_underscore_fields,
644 clippy::style
645 )]
646 const _: () = {
647 use alloy::sol_types as alloy_sol_types;
648 #[doc(hidden)]
649 type UnderlyingSolTuple<'a> = ();
650 #[doc(hidden)]
651 type UnderlyingRustTuple<'a> = ();
652 #[cfg(test)]
653 #[allow(dead_code, unreachable_patterns)]
654 fn _type_assertion(
655 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
656 ) {
657 match _t {
658 alloy_sol_types::private::AssertTypeEq::<
659 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
660 >(_) => {}
661 }
662 }
663 #[automatically_derived]
664 #[doc(hidden)]
665 impl ::core::convert::From<OnlyUnderlyingToken> for UnderlyingRustTuple<'_> {
666 fn from(value: OnlyUnderlyingToken) -> Self {
667 ()
668 }
669 }
670 #[automatically_derived]
671 #[doc(hidden)]
672 impl ::core::convert::From<UnderlyingRustTuple<'_>> for OnlyUnderlyingToken {
673 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
674 Self {}
675 }
676 }
677 #[automatically_derived]
678 impl alloy_sol_types::SolError for OnlyUnderlyingToken {
679 type Parameters<'a> = UnderlyingSolTuple<'a>;
680 type Token<'a> = <Self::Parameters<
681 'a,
682 > as alloy_sol_types::SolType>::Token<'a>;
683 const SIGNATURE: &'static str = "OnlyUnderlyingToken()";
684 const SELECTOR: [u8; 4] = [196u8, 170u8, 247u8, 64u8];
685 #[inline]
686 fn new<'a>(
687 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
688 ) -> Self {
689 tuple.into()
690 }
691 #[inline]
692 fn tokenize(&self) -> Self::Token<'_> {
693 ()
694 }
695 }
696 };
697 #[derive(Default, Debug, PartialEq, Eq, Hash)]
698 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
703 #[derive(Clone)]
704 pub struct TotalSharesExceedsMax {}
705 #[allow(
706 non_camel_case_types,
707 non_snake_case,
708 clippy::pub_underscore_fields,
709 clippy::style
710 )]
711 const _: () = {
712 use alloy::sol_types as alloy_sol_types;
713 #[doc(hidden)]
714 type UnderlyingSolTuple<'a> = ();
715 #[doc(hidden)]
716 type UnderlyingRustTuple<'a> = ();
717 #[cfg(test)]
718 #[allow(dead_code, unreachable_patterns)]
719 fn _type_assertion(
720 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
721 ) {
722 match _t {
723 alloy_sol_types::private::AssertTypeEq::<
724 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
725 >(_) => {}
726 }
727 }
728 #[automatically_derived]
729 #[doc(hidden)]
730 impl ::core::convert::From<TotalSharesExceedsMax> for UnderlyingRustTuple<'_> {
731 fn from(value: TotalSharesExceedsMax) -> Self {
732 ()
733 }
734 }
735 #[automatically_derived]
736 #[doc(hidden)]
737 impl ::core::convert::From<UnderlyingRustTuple<'_>> for TotalSharesExceedsMax {
738 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
739 Self {}
740 }
741 }
742 #[automatically_derived]
743 impl alloy_sol_types::SolError for TotalSharesExceedsMax {
744 type Parameters<'a> = UnderlyingSolTuple<'a>;
745 type Token<'a> = <Self::Parameters<
746 'a,
747 > as alloy_sol_types::SolType>::Token<'a>;
748 const SIGNATURE: &'static str = "TotalSharesExceedsMax()";
749 const SELECTOR: [u8; 4] = [94u8, 41u8, 209u8, 70u8];
750 #[inline]
751 fn new<'a>(
752 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
753 ) -> Self {
754 tuple.into()
755 }
756 #[inline]
757 fn tokenize(&self) -> Self::Token<'_> {
758 ()
759 }
760 }
761 };
762 #[derive(Default, Debug, PartialEq, Eq, Hash)]
763 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
768 #[derive(Clone)]
769 pub struct WithdrawalAmountExceedsTotalDeposits {}
770 #[allow(
771 non_camel_case_types,
772 non_snake_case,
773 clippy::pub_underscore_fields,
774 clippy::style
775 )]
776 const _: () = {
777 use alloy::sol_types as alloy_sol_types;
778 #[doc(hidden)]
779 type UnderlyingSolTuple<'a> = ();
780 #[doc(hidden)]
781 type UnderlyingRustTuple<'a> = ();
782 #[cfg(test)]
783 #[allow(dead_code, unreachable_patterns)]
784 fn _type_assertion(
785 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
786 ) {
787 match _t {
788 alloy_sol_types::private::AssertTypeEq::<
789 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
790 >(_) => {}
791 }
792 }
793 #[automatically_derived]
794 #[doc(hidden)]
795 impl ::core::convert::From<WithdrawalAmountExceedsTotalDeposits>
796 for UnderlyingRustTuple<'_> {
797 fn from(value: WithdrawalAmountExceedsTotalDeposits) -> Self {
798 ()
799 }
800 }
801 #[automatically_derived]
802 #[doc(hidden)]
803 impl ::core::convert::From<UnderlyingRustTuple<'_>>
804 for WithdrawalAmountExceedsTotalDeposits {
805 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
806 Self {}
807 }
808 }
809 #[automatically_derived]
810 impl alloy_sol_types::SolError for WithdrawalAmountExceedsTotalDeposits {
811 type Parameters<'a> = UnderlyingSolTuple<'a>;
812 type Token<'a> = <Self::Parameters<
813 'a,
814 > as alloy_sol_types::SolType>::Token<'a>;
815 const SIGNATURE: &'static str = "WithdrawalAmountExceedsTotalDeposits()";
816 const SELECTOR: [u8; 4] = [180u8, 105u8, 223u8, 48u8];
817 #[inline]
818 fn new<'a>(
819 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
820 ) -> Self {
821 tuple.into()
822 }
823 #[inline]
824 fn tokenize(&self) -> Self::Token<'_> {
825 ()
826 }
827 }
828 };
829 #[derive(Default, Debug, PartialEq, Eq, Hash)]
830 #[allow(
835 non_camel_case_types,
836 non_snake_case,
837 clippy::pub_underscore_fields,
838 clippy::style
839 )]
840 #[derive(Clone)]
841 pub struct ExchangeRateEmitted {
842 #[allow(missing_docs)]
843 pub rate: alloy::sol_types::private::primitives::aliases::U256,
844 }
845 #[allow(
846 non_camel_case_types,
847 non_snake_case,
848 clippy::pub_underscore_fields,
849 clippy::style
850 )]
851 const _: () = {
852 use alloy::sol_types as alloy_sol_types;
853 #[automatically_derived]
854 impl alloy_sol_types::SolEvent for ExchangeRateEmitted {
855 type DataTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
856 type DataToken<'a> = <Self::DataTuple<
857 'a,
858 > as alloy_sol_types::SolType>::Token<'a>;
859 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
860 const SIGNATURE: &'static str = "ExchangeRateEmitted(uint256)";
861 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
862 210u8, 73u8, 79u8, 52u8, 121u8, 229u8, 218u8, 73u8, 211u8, 134u8, 101u8,
863 124u8, 41u8, 44u8, 97u8, 11u8, 91u8, 1u8, 223u8, 49u8, 61u8, 7u8, 198u8,
864 46u8, 176u8, 207u8, 164u8, 153u8, 36u8, 163u8, 27u8, 232u8,
865 ]);
866 const ANONYMOUS: bool = false;
867 #[allow(unused_variables)]
868 #[inline]
869 fn new(
870 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
871 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
872 ) -> Self {
873 Self { rate: data.0 }
874 }
875 #[inline]
876 fn check_signature(
877 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
878 ) -> alloy_sol_types::Result<()> {
879 if topics.0 != Self::SIGNATURE_HASH {
880 return Err(
881 alloy_sol_types::Error::invalid_event_signature_hash(
882 Self::SIGNATURE,
883 topics.0,
884 Self::SIGNATURE_HASH,
885 ),
886 );
887 }
888 Ok(())
889 }
890 #[inline]
891 fn tokenize_body(&self) -> Self::DataToken<'_> {
892 (
893 <alloy::sol_types::sol_data::Uint<
894 256,
895 > as alloy_sol_types::SolType>::tokenize(&self.rate),
896 )
897 }
898 #[inline]
899 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
900 (Self::SIGNATURE_HASH.into(),)
901 }
902 #[inline]
903 fn encode_topics_raw(
904 &self,
905 out: &mut [alloy_sol_types::abi::token::WordToken],
906 ) -> alloy_sol_types::Result<()> {
907 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
908 return Err(alloy_sol_types::Error::Overrun);
909 }
910 out[0usize] = alloy_sol_types::abi::token::WordToken(
911 Self::SIGNATURE_HASH,
912 );
913 Ok(())
914 }
915 }
916 #[automatically_derived]
917 impl alloy_sol_types::private::IntoLogData for ExchangeRateEmitted {
918 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
919 From::from(self)
920 }
921 fn into_log_data(self) -> alloy_sol_types::private::LogData {
922 From::from(&self)
923 }
924 }
925 #[automatically_derived]
926 impl From<&ExchangeRateEmitted> for alloy_sol_types::private::LogData {
927 #[inline]
928 fn from(this: &ExchangeRateEmitted) -> alloy_sol_types::private::LogData {
929 alloy_sol_types::SolEvent::encode_log_data(this)
930 }
931 }
932 };
933 #[derive(Default, Debug, PartialEq, Eq, Hash)]
934 #[allow(
939 non_camel_case_types,
940 non_snake_case,
941 clippy::pub_underscore_fields,
942 clippy::style
943 )]
944 #[derive(Clone)]
945 pub struct StrategyTokenSet {
946 #[allow(missing_docs)]
947 pub token: alloy::sol_types::private::Address,
948 #[allow(missing_docs)]
949 pub decimals: u8,
950 }
951 #[allow(
952 non_camel_case_types,
953 non_snake_case,
954 clippy::pub_underscore_fields,
955 clippy::style
956 )]
957 const _: () = {
958 use alloy::sol_types as alloy_sol_types;
959 #[automatically_derived]
960 impl alloy_sol_types::SolEvent for StrategyTokenSet {
961 type DataTuple<'a> = (
962 alloy::sol_types::sol_data::Address,
963 alloy::sol_types::sol_data::Uint<8>,
964 );
965 type DataToken<'a> = <Self::DataTuple<
966 'a,
967 > as alloy_sol_types::SolType>::Token<'a>;
968 type TopicList = (alloy_sol_types::sol_data::FixedBytes<32>,);
969 const SIGNATURE: &'static str = "StrategyTokenSet(address,uint8)";
970 const SIGNATURE_HASH: alloy_sol_types::private::B256 = alloy_sol_types::private::B256::new([
971 28u8, 84u8, 7u8, 7u8, 176u8, 14u8, 181u8, 66u8, 123u8, 107u8, 119u8,
972 79u8, 199u8, 153u8, 215u8, 86u8, 81u8, 106u8, 84u8, 174u8, 225u8, 8u8,
973 182u8, 75u8, 50u8, 122u8, 204u8, 85u8, 175u8, 85u8, 117u8, 7u8,
974 ]);
975 const ANONYMOUS: bool = false;
976 #[allow(unused_variables)]
977 #[inline]
978 fn new(
979 topics: <Self::TopicList as alloy_sol_types::SolType>::RustType,
980 data: <Self::DataTuple<'_> as alloy_sol_types::SolType>::RustType,
981 ) -> Self {
982 Self {
983 token: data.0,
984 decimals: data.1,
985 }
986 }
987 #[inline]
988 fn check_signature(
989 topics: &<Self::TopicList as alloy_sol_types::SolType>::RustType,
990 ) -> alloy_sol_types::Result<()> {
991 if topics.0 != Self::SIGNATURE_HASH {
992 return Err(
993 alloy_sol_types::Error::invalid_event_signature_hash(
994 Self::SIGNATURE,
995 topics.0,
996 Self::SIGNATURE_HASH,
997 ),
998 );
999 }
1000 Ok(())
1001 }
1002 #[inline]
1003 fn tokenize_body(&self) -> Self::DataToken<'_> {
1004 (
1005 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1006 &self.token,
1007 ),
1008 <alloy::sol_types::sol_data::Uint<
1009 8,
1010 > as alloy_sol_types::SolType>::tokenize(&self.decimals),
1011 )
1012 }
1013 #[inline]
1014 fn topics(&self) -> <Self::TopicList as alloy_sol_types::SolType>::RustType {
1015 (Self::SIGNATURE_HASH.into(),)
1016 }
1017 #[inline]
1018 fn encode_topics_raw(
1019 &self,
1020 out: &mut [alloy_sol_types::abi::token::WordToken],
1021 ) -> alloy_sol_types::Result<()> {
1022 if out.len() < <Self::TopicList as alloy_sol_types::TopicList>::COUNT {
1023 return Err(alloy_sol_types::Error::Overrun);
1024 }
1025 out[0usize] = alloy_sol_types::abi::token::WordToken(
1026 Self::SIGNATURE_HASH,
1027 );
1028 Ok(())
1029 }
1030 }
1031 #[automatically_derived]
1032 impl alloy_sol_types::private::IntoLogData for StrategyTokenSet {
1033 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
1034 From::from(self)
1035 }
1036 fn into_log_data(self) -> alloy_sol_types::private::LogData {
1037 From::from(&self)
1038 }
1039 }
1040 #[automatically_derived]
1041 impl From<&StrategyTokenSet> for alloy_sol_types::private::LogData {
1042 #[inline]
1043 fn from(this: &StrategyTokenSet) -> alloy_sol_types::private::LogData {
1044 alloy_sol_types::SolEvent::encode_log_data(this)
1045 }
1046 }
1047 };
1048 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1049 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1054 #[derive(Clone)]
1055 pub struct depositCall {
1056 #[allow(missing_docs)]
1057 pub token: alloy::sol_types::private::Address,
1058 #[allow(missing_docs)]
1059 pub amount: alloy::sol_types::private::primitives::aliases::U256,
1060 }
1061 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1062 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1064 #[derive(Clone)]
1065 pub struct depositReturn {
1066 #[allow(missing_docs)]
1067 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1068 }
1069 #[allow(
1070 non_camel_case_types,
1071 non_snake_case,
1072 clippy::pub_underscore_fields,
1073 clippy::style
1074 )]
1075 const _: () = {
1076 use alloy::sol_types as alloy_sol_types;
1077 {
1078 #[doc(hidden)]
1079 type UnderlyingSolTuple<'a> = (
1080 alloy::sol_types::sol_data::Address,
1081 alloy::sol_types::sol_data::Uint<256>,
1082 );
1083 #[doc(hidden)]
1084 type UnderlyingRustTuple<'a> = (
1085 alloy::sol_types::private::Address,
1086 alloy::sol_types::private::primitives::aliases::U256,
1087 );
1088 #[cfg(test)]
1089 #[allow(dead_code, unreachable_patterns)]
1090 fn _type_assertion(
1091 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1092 ) {
1093 match _t {
1094 alloy_sol_types::private::AssertTypeEq::<
1095 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1096 >(_) => {}
1097 }
1098 }
1099 #[automatically_derived]
1100 #[doc(hidden)]
1101 impl ::core::convert::From<depositCall> for UnderlyingRustTuple<'_> {
1102 fn from(value: depositCall) -> Self {
1103 (value.token, value.amount)
1104 }
1105 }
1106 #[automatically_derived]
1107 #[doc(hidden)]
1108 impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositCall {
1109 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1110 Self {
1111 token: tuple.0,
1112 amount: tuple.1,
1113 }
1114 }
1115 }
1116 }
1117 {
1118 #[doc(hidden)]
1119 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1120 #[doc(hidden)]
1121 type UnderlyingRustTuple<'a> = (
1122 alloy::sol_types::private::primitives::aliases::U256,
1123 );
1124 #[cfg(test)]
1125 #[allow(dead_code, unreachable_patterns)]
1126 fn _type_assertion(
1127 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1128 ) {
1129 match _t {
1130 alloy_sol_types::private::AssertTypeEq::<
1131 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1132 >(_) => {}
1133 }
1134 }
1135 #[automatically_derived]
1136 #[doc(hidden)]
1137 impl ::core::convert::From<depositReturn> for UnderlyingRustTuple<'_> {
1138 fn from(value: depositReturn) -> Self {
1139 (value._0,)
1140 }
1141 }
1142 #[automatically_derived]
1143 #[doc(hidden)]
1144 impl ::core::convert::From<UnderlyingRustTuple<'_>> for depositReturn {
1145 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1146 Self { _0: tuple.0 }
1147 }
1148 }
1149 }
1150 #[automatically_derived]
1151 impl alloy_sol_types::SolCall for depositCall {
1152 type Parameters<'a> = (
1153 alloy::sol_types::sol_data::Address,
1154 alloy::sol_types::sol_data::Uint<256>,
1155 );
1156 type Token<'a> = <Self::Parameters<
1157 'a,
1158 > as alloy_sol_types::SolType>::Token<'a>;
1159 type Return = depositReturn;
1160 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1161 type ReturnToken<'a> = <Self::ReturnTuple<
1162 'a,
1163 > as alloy_sol_types::SolType>::Token<'a>;
1164 const SIGNATURE: &'static str = "deposit(address,uint256)";
1165 const SELECTOR: [u8; 4] = [71u8, 231u8, 239u8, 36u8];
1166 #[inline]
1167 fn new<'a>(
1168 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1169 ) -> Self {
1170 tuple.into()
1171 }
1172 #[inline]
1173 fn tokenize(&self) -> Self::Token<'_> {
1174 (
1175 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1176 &self.token,
1177 ),
1178 <alloy::sol_types::sol_data::Uint<
1179 256,
1180 > as alloy_sol_types::SolType>::tokenize(&self.amount),
1181 )
1182 }
1183 #[inline]
1184 fn abi_decode_returns(
1185 data: &[u8],
1186 validate: bool,
1187 ) -> alloy_sol_types::Result<Self::Return> {
1188 <Self::ReturnTuple<
1189 '_,
1190 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1191 .map(Into::into)
1192 }
1193 }
1194 };
1195 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1196 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1201 #[derive(Clone)]
1202 pub struct explanationCall {}
1203 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1204 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1206 #[derive(Clone)]
1207 pub struct explanationReturn {
1208 #[allow(missing_docs)]
1209 pub _0: alloy::sol_types::private::String,
1210 }
1211 #[allow(
1212 non_camel_case_types,
1213 non_snake_case,
1214 clippy::pub_underscore_fields,
1215 clippy::style
1216 )]
1217 const _: () = {
1218 use alloy::sol_types as alloy_sol_types;
1219 {
1220 #[doc(hidden)]
1221 type UnderlyingSolTuple<'a> = ();
1222 #[doc(hidden)]
1223 type UnderlyingRustTuple<'a> = ();
1224 #[cfg(test)]
1225 #[allow(dead_code, unreachable_patterns)]
1226 fn _type_assertion(
1227 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1228 ) {
1229 match _t {
1230 alloy_sol_types::private::AssertTypeEq::<
1231 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1232 >(_) => {}
1233 }
1234 }
1235 #[automatically_derived]
1236 #[doc(hidden)]
1237 impl ::core::convert::From<explanationCall> for UnderlyingRustTuple<'_> {
1238 fn from(value: explanationCall) -> Self {
1239 ()
1240 }
1241 }
1242 #[automatically_derived]
1243 #[doc(hidden)]
1244 impl ::core::convert::From<UnderlyingRustTuple<'_>> for explanationCall {
1245 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1246 Self {}
1247 }
1248 }
1249 }
1250 {
1251 #[doc(hidden)]
1252 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
1253 #[doc(hidden)]
1254 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
1255 #[cfg(test)]
1256 #[allow(dead_code, unreachable_patterns)]
1257 fn _type_assertion(
1258 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1259 ) {
1260 match _t {
1261 alloy_sol_types::private::AssertTypeEq::<
1262 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1263 >(_) => {}
1264 }
1265 }
1266 #[automatically_derived]
1267 #[doc(hidden)]
1268 impl ::core::convert::From<explanationReturn> for UnderlyingRustTuple<'_> {
1269 fn from(value: explanationReturn) -> Self {
1270 (value._0,)
1271 }
1272 }
1273 #[automatically_derived]
1274 #[doc(hidden)]
1275 impl ::core::convert::From<UnderlyingRustTuple<'_>> for explanationReturn {
1276 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1277 Self { _0: tuple.0 }
1278 }
1279 }
1280 }
1281 #[automatically_derived]
1282 impl alloy_sol_types::SolCall for explanationCall {
1283 type Parameters<'a> = ();
1284 type Token<'a> = <Self::Parameters<
1285 'a,
1286 > as alloy_sol_types::SolType>::Token<'a>;
1287 type Return = explanationReturn;
1288 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
1289 type ReturnToken<'a> = <Self::ReturnTuple<
1290 'a,
1291 > as alloy_sol_types::SolType>::Token<'a>;
1292 const SIGNATURE: &'static str = "explanation()";
1293 const SELECTOR: [u8; 4] = [171u8, 89u8, 33u8, 225u8];
1294 #[inline]
1295 fn new<'a>(
1296 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1297 ) -> Self {
1298 tuple.into()
1299 }
1300 #[inline]
1301 fn tokenize(&self) -> Self::Token<'_> {
1302 ()
1303 }
1304 #[inline]
1305 fn abi_decode_returns(
1306 data: &[u8],
1307 validate: bool,
1308 ) -> alloy_sol_types::Result<Self::Return> {
1309 <Self::ReturnTuple<
1310 '_,
1311 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1312 .map(Into::into)
1313 }
1314 }
1315 };
1316 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1317 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1322 #[derive(Clone)]
1323 pub struct sharesCall {
1324 #[allow(missing_docs)]
1325 pub user: alloy::sol_types::private::Address,
1326 }
1327 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1328 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1330 #[derive(Clone)]
1331 pub struct sharesReturn {
1332 #[allow(missing_docs)]
1333 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1334 }
1335 #[allow(
1336 non_camel_case_types,
1337 non_snake_case,
1338 clippy::pub_underscore_fields,
1339 clippy::style
1340 )]
1341 const _: () = {
1342 use alloy::sol_types as alloy_sol_types;
1343 {
1344 #[doc(hidden)]
1345 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
1346 #[doc(hidden)]
1347 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
1348 #[cfg(test)]
1349 #[allow(dead_code, unreachable_patterns)]
1350 fn _type_assertion(
1351 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1352 ) {
1353 match _t {
1354 alloy_sol_types::private::AssertTypeEq::<
1355 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1356 >(_) => {}
1357 }
1358 }
1359 #[automatically_derived]
1360 #[doc(hidden)]
1361 impl ::core::convert::From<sharesCall> for UnderlyingRustTuple<'_> {
1362 fn from(value: sharesCall) -> Self {
1363 (value.user,)
1364 }
1365 }
1366 #[automatically_derived]
1367 #[doc(hidden)]
1368 impl ::core::convert::From<UnderlyingRustTuple<'_>> for sharesCall {
1369 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1370 Self { user: tuple.0 }
1371 }
1372 }
1373 }
1374 {
1375 #[doc(hidden)]
1376 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1377 #[doc(hidden)]
1378 type UnderlyingRustTuple<'a> = (
1379 alloy::sol_types::private::primitives::aliases::U256,
1380 );
1381 #[cfg(test)]
1382 #[allow(dead_code, unreachable_patterns)]
1383 fn _type_assertion(
1384 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1385 ) {
1386 match _t {
1387 alloy_sol_types::private::AssertTypeEq::<
1388 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1389 >(_) => {}
1390 }
1391 }
1392 #[automatically_derived]
1393 #[doc(hidden)]
1394 impl ::core::convert::From<sharesReturn> for UnderlyingRustTuple<'_> {
1395 fn from(value: sharesReturn) -> Self {
1396 (value._0,)
1397 }
1398 }
1399 #[automatically_derived]
1400 #[doc(hidden)]
1401 impl ::core::convert::From<UnderlyingRustTuple<'_>> for sharesReturn {
1402 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1403 Self { _0: tuple.0 }
1404 }
1405 }
1406 }
1407 #[automatically_derived]
1408 impl alloy_sol_types::SolCall for sharesCall {
1409 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
1410 type Token<'a> = <Self::Parameters<
1411 'a,
1412 > as alloy_sol_types::SolType>::Token<'a>;
1413 type Return = sharesReturn;
1414 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1415 type ReturnToken<'a> = <Self::ReturnTuple<
1416 'a,
1417 > as alloy_sol_types::SolType>::Token<'a>;
1418 const SIGNATURE: &'static str = "shares(address)";
1419 const SELECTOR: [u8; 4] = [206u8, 124u8, 42u8, 194u8];
1420 #[inline]
1421 fn new<'a>(
1422 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1423 ) -> Self {
1424 tuple.into()
1425 }
1426 #[inline]
1427 fn tokenize(&self) -> Self::Token<'_> {
1428 (
1429 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
1430 &self.user,
1431 ),
1432 )
1433 }
1434 #[inline]
1435 fn abi_decode_returns(
1436 data: &[u8],
1437 validate: bool,
1438 ) -> alloy_sol_types::Result<Self::Return> {
1439 <Self::ReturnTuple<
1440 '_,
1441 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1442 .map(Into::into)
1443 }
1444 }
1445 };
1446 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1447 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1452 #[derive(Clone)]
1453 pub struct sharesToUnderlyingCall {
1454 #[allow(missing_docs)]
1455 pub amountShares: alloy::sol_types::private::primitives::aliases::U256,
1456 }
1457 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1458 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1460 #[derive(Clone)]
1461 pub struct sharesToUnderlyingReturn {
1462 #[allow(missing_docs)]
1463 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1464 }
1465 #[allow(
1466 non_camel_case_types,
1467 non_snake_case,
1468 clippy::pub_underscore_fields,
1469 clippy::style
1470 )]
1471 const _: () = {
1472 use alloy::sol_types as alloy_sol_types;
1473 {
1474 #[doc(hidden)]
1475 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1476 #[doc(hidden)]
1477 type UnderlyingRustTuple<'a> = (
1478 alloy::sol_types::private::primitives::aliases::U256,
1479 );
1480 #[cfg(test)]
1481 #[allow(dead_code, unreachable_patterns)]
1482 fn _type_assertion(
1483 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1484 ) {
1485 match _t {
1486 alloy_sol_types::private::AssertTypeEq::<
1487 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1488 >(_) => {}
1489 }
1490 }
1491 #[automatically_derived]
1492 #[doc(hidden)]
1493 impl ::core::convert::From<sharesToUnderlyingCall>
1494 for UnderlyingRustTuple<'_> {
1495 fn from(value: sharesToUnderlyingCall) -> Self {
1496 (value.amountShares,)
1497 }
1498 }
1499 #[automatically_derived]
1500 #[doc(hidden)]
1501 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1502 for sharesToUnderlyingCall {
1503 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1504 Self { amountShares: tuple.0 }
1505 }
1506 }
1507 }
1508 {
1509 #[doc(hidden)]
1510 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1511 #[doc(hidden)]
1512 type UnderlyingRustTuple<'a> = (
1513 alloy::sol_types::private::primitives::aliases::U256,
1514 );
1515 #[cfg(test)]
1516 #[allow(dead_code, unreachable_patterns)]
1517 fn _type_assertion(
1518 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1519 ) {
1520 match _t {
1521 alloy_sol_types::private::AssertTypeEq::<
1522 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1523 >(_) => {}
1524 }
1525 }
1526 #[automatically_derived]
1527 #[doc(hidden)]
1528 impl ::core::convert::From<sharesToUnderlyingReturn>
1529 for UnderlyingRustTuple<'_> {
1530 fn from(value: sharesToUnderlyingReturn) -> Self {
1531 (value._0,)
1532 }
1533 }
1534 #[automatically_derived]
1535 #[doc(hidden)]
1536 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1537 for sharesToUnderlyingReturn {
1538 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1539 Self { _0: tuple.0 }
1540 }
1541 }
1542 }
1543 #[automatically_derived]
1544 impl alloy_sol_types::SolCall for sharesToUnderlyingCall {
1545 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1546 type Token<'a> = <Self::Parameters<
1547 'a,
1548 > as alloy_sol_types::SolType>::Token<'a>;
1549 type Return = sharesToUnderlyingReturn;
1550 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1551 type ReturnToken<'a> = <Self::ReturnTuple<
1552 'a,
1553 > as alloy_sol_types::SolType>::Token<'a>;
1554 const SIGNATURE: &'static str = "sharesToUnderlying(uint256)";
1555 const SELECTOR: [u8; 4] = [243u8, 231u8, 56u8, 117u8];
1556 #[inline]
1557 fn new<'a>(
1558 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1559 ) -> Self {
1560 tuple.into()
1561 }
1562 #[inline]
1563 fn tokenize(&self) -> Self::Token<'_> {
1564 (
1565 <alloy::sol_types::sol_data::Uint<
1566 256,
1567 > as alloy_sol_types::SolType>::tokenize(&self.amountShares),
1568 )
1569 }
1570 #[inline]
1571 fn abi_decode_returns(
1572 data: &[u8],
1573 validate: bool,
1574 ) -> alloy_sol_types::Result<Self::Return> {
1575 <Self::ReturnTuple<
1576 '_,
1577 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1578 .map(Into::into)
1579 }
1580 }
1581 };
1582 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1583 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1588 #[derive(Clone)]
1589 pub struct sharesToUnderlyingViewCall {
1590 #[allow(missing_docs)]
1591 pub amountShares: alloy::sol_types::private::primitives::aliases::U256,
1592 }
1593 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1594 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1596 #[derive(Clone)]
1597 pub struct sharesToUnderlyingViewReturn {
1598 #[allow(missing_docs)]
1599 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1600 }
1601 #[allow(
1602 non_camel_case_types,
1603 non_snake_case,
1604 clippy::pub_underscore_fields,
1605 clippy::style
1606 )]
1607 const _: () = {
1608 use alloy::sol_types as alloy_sol_types;
1609 {
1610 #[doc(hidden)]
1611 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1612 #[doc(hidden)]
1613 type UnderlyingRustTuple<'a> = (
1614 alloy::sol_types::private::primitives::aliases::U256,
1615 );
1616 #[cfg(test)]
1617 #[allow(dead_code, unreachable_patterns)]
1618 fn _type_assertion(
1619 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1620 ) {
1621 match _t {
1622 alloy_sol_types::private::AssertTypeEq::<
1623 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1624 >(_) => {}
1625 }
1626 }
1627 #[automatically_derived]
1628 #[doc(hidden)]
1629 impl ::core::convert::From<sharesToUnderlyingViewCall>
1630 for UnderlyingRustTuple<'_> {
1631 fn from(value: sharesToUnderlyingViewCall) -> Self {
1632 (value.amountShares,)
1633 }
1634 }
1635 #[automatically_derived]
1636 #[doc(hidden)]
1637 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1638 for sharesToUnderlyingViewCall {
1639 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1640 Self { amountShares: tuple.0 }
1641 }
1642 }
1643 }
1644 {
1645 #[doc(hidden)]
1646 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1647 #[doc(hidden)]
1648 type UnderlyingRustTuple<'a> = (
1649 alloy::sol_types::private::primitives::aliases::U256,
1650 );
1651 #[cfg(test)]
1652 #[allow(dead_code, unreachable_patterns)]
1653 fn _type_assertion(
1654 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1655 ) {
1656 match _t {
1657 alloy_sol_types::private::AssertTypeEq::<
1658 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1659 >(_) => {}
1660 }
1661 }
1662 #[automatically_derived]
1663 #[doc(hidden)]
1664 impl ::core::convert::From<sharesToUnderlyingViewReturn>
1665 for UnderlyingRustTuple<'_> {
1666 fn from(value: sharesToUnderlyingViewReturn) -> Self {
1667 (value._0,)
1668 }
1669 }
1670 #[automatically_derived]
1671 #[doc(hidden)]
1672 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1673 for sharesToUnderlyingViewReturn {
1674 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1675 Self { _0: tuple.0 }
1676 }
1677 }
1678 }
1679 #[automatically_derived]
1680 impl alloy_sol_types::SolCall for sharesToUnderlyingViewCall {
1681 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1682 type Token<'a> = <Self::Parameters<
1683 'a,
1684 > as alloy_sol_types::SolType>::Token<'a>;
1685 type Return = sharesToUnderlyingViewReturn;
1686 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1687 type ReturnToken<'a> = <Self::ReturnTuple<
1688 'a,
1689 > as alloy_sol_types::SolType>::Token<'a>;
1690 const SIGNATURE: &'static str = "sharesToUnderlyingView(uint256)";
1691 const SELECTOR: [u8; 4] = [122u8, 139u8, 38u8, 55u8];
1692 #[inline]
1693 fn new<'a>(
1694 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1695 ) -> Self {
1696 tuple.into()
1697 }
1698 #[inline]
1699 fn tokenize(&self) -> Self::Token<'_> {
1700 (
1701 <alloy::sol_types::sol_data::Uint<
1702 256,
1703 > as alloy_sol_types::SolType>::tokenize(&self.amountShares),
1704 )
1705 }
1706 #[inline]
1707 fn abi_decode_returns(
1708 data: &[u8],
1709 validate: bool,
1710 ) -> alloy_sol_types::Result<Self::Return> {
1711 <Self::ReturnTuple<
1712 '_,
1713 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1714 .map(Into::into)
1715 }
1716 }
1717 };
1718 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1719 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1724 #[derive(Clone)]
1725 pub struct totalSharesCall {}
1726 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1727 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1729 #[derive(Clone)]
1730 pub struct totalSharesReturn {
1731 #[allow(missing_docs)]
1732 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1733 }
1734 #[allow(
1735 non_camel_case_types,
1736 non_snake_case,
1737 clippy::pub_underscore_fields,
1738 clippy::style
1739 )]
1740 const _: () = {
1741 use alloy::sol_types as alloy_sol_types;
1742 {
1743 #[doc(hidden)]
1744 type UnderlyingSolTuple<'a> = ();
1745 #[doc(hidden)]
1746 type UnderlyingRustTuple<'a> = ();
1747 #[cfg(test)]
1748 #[allow(dead_code, unreachable_patterns)]
1749 fn _type_assertion(
1750 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1751 ) {
1752 match _t {
1753 alloy_sol_types::private::AssertTypeEq::<
1754 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1755 >(_) => {}
1756 }
1757 }
1758 #[automatically_derived]
1759 #[doc(hidden)]
1760 impl ::core::convert::From<totalSharesCall> for UnderlyingRustTuple<'_> {
1761 fn from(value: totalSharesCall) -> Self {
1762 ()
1763 }
1764 }
1765 #[automatically_derived]
1766 #[doc(hidden)]
1767 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSharesCall {
1768 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1769 Self {}
1770 }
1771 }
1772 }
1773 {
1774 #[doc(hidden)]
1775 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1776 #[doc(hidden)]
1777 type UnderlyingRustTuple<'a> = (
1778 alloy::sol_types::private::primitives::aliases::U256,
1779 );
1780 #[cfg(test)]
1781 #[allow(dead_code, unreachable_patterns)]
1782 fn _type_assertion(
1783 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1784 ) {
1785 match _t {
1786 alloy_sol_types::private::AssertTypeEq::<
1787 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1788 >(_) => {}
1789 }
1790 }
1791 #[automatically_derived]
1792 #[doc(hidden)]
1793 impl ::core::convert::From<totalSharesReturn> for UnderlyingRustTuple<'_> {
1794 fn from(value: totalSharesReturn) -> Self {
1795 (value._0,)
1796 }
1797 }
1798 #[automatically_derived]
1799 #[doc(hidden)]
1800 impl ::core::convert::From<UnderlyingRustTuple<'_>> for totalSharesReturn {
1801 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1802 Self { _0: tuple.0 }
1803 }
1804 }
1805 }
1806 #[automatically_derived]
1807 impl alloy_sol_types::SolCall for totalSharesCall {
1808 type Parameters<'a> = ();
1809 type Token<'a> = <Self::Parameters<
1810 'a,
1811 > as alloy_sol_types::SolType>::Token<'a>;
1812 type Return = totalSharesReturn;
1813 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1814 type ReturnToken<'a> = <Self::ReturnTuple<
1815 'a,
1816 > as alloy_sol_types::SolType>::Token<'a>;
1817 const SIGNATURE: &'static str = "totalShares()";
1818 const SELECTOR: [u8; 4] = [58u8, 152u8, 239u8, 57u8];
1819 #[inline]
1820 fn new<'a>(
1821 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1822 ) -> Self {
1823 tuple.into()
1824 }
1825 #[inline]
1826 fn tokenize(&self) -> Self::Token<'_> {
1827 ()
1828 }
1829 #[inline]
1830 fn abi_decode_returns(
1831 data: &[u8],
1832 validate: bool,
1833 ) -> alloy_sol_types::Result<Self::Return> {
1834 <Self::ReturnTuple<
1835 '_,
1836 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1837 .map(Into::into)
1838 }
1839 }
1840 };
1841 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1842 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1847 #[derive(Clone)]
1848 pub struct underlyingToSharesCall {
1849 #[allow(missing_docs)]
1850 pub amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
1851 }
1852 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1853 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1855 #[derive(Clone)]
1856 pub struct underlyingToSharesReturn {
1857 #[allow(missing_docs)]
1858 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1859 }
1860 #[allow(
1861 non_camel_case_types,
1862 non_snake_case,
1863 clippy::pub_underscore_fields,
1864 clippy::style
1865 )]
1866 const _: () = {
1867 use alloy::sol_types as alloy_sol_types;
1868 {
1869 #[doc(hidden)]
1870 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1871 #[doc(hidden)]
1872 type UnderlyingRustTuple<'a> = (
1873 alloy::sol_types::private::primitives::aliases::U256,
1874 );
1875 #[cfg(test)]
1876 #[allow(dead_code, unreachable_patterns)]
1877 fn _type_assertion(
1878 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1879 ) {
1880 match _t {
1881 alloy_sol_types::private::AssertTypeEq::<
1882 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1883 >(_) => {}
1884 }
1885 }
1886 #[automatically_derived]
1887 #[doc(hidden)]
1888 impl ::core::convert::From<underlyingToSharesCall>
1889 for UnderlyingRustTuple<'_> {
1890 fn from(value: underlyingToSharesCall) -> Self {
1891 (value.amountUnderlying,)
1892 }
1893 }
1894 #[automatically_derived]
1895 #[doc(hidden)]
1896 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1897 for underlyingToSharesCall {
1898 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1899 Self { amountUnderlying: tuple.0 }
1900 }
1901 }
1902 }
1903 {
1904 #[doc(hidden)]
1905 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1906 #[doc(hidden)]
1907 type UnderlyingRustTuple<'a> = (
1908 alloy::sol_types::private::primitives::aliases::U256,
1909 );
1910 #[cfg(test)]
1911 #[allow(dead_code, unreachable_patterns)]
1912 fn _type_assertion(
1913 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
1914 ) {
1915 match _t {
1916 alloy_sol_types::private::AssertTypeEq::<
1917 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
1918 >(_) => {}
1919 }
1920 }
1921 #[automatically_derived]
1922 #[doc(hidden)]
1923 impl ::core::convert::From<underlyingToSharesReturn>
1924 for UnderlyingRustTuple<'_> {
1925 fn from(value: underlyingToSharesReturn) -> Self {
1926 (value._0,)
1927 }
1928 }
1929 #[automatically_derived]
1930 #[doc(hidden)]
1931 impl ::core::convert::From<UnderlyingRustTuple<'_>>
1932 for underlyingToSharesReturn {
1933 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
1934 Self { _0: tuple.0 }
1935 }
1936 }
1937 }
1938 #[automatically_derived]
1939 impl alloy_sol_types::SolCall for underlyingToSharesCall {
1940 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1941 type Token<'a> = <Self::Parameters<
1942 'a,
1943 > as alloy_sol_types::SolType>::Token<'a>;
1944 type Return = underlyingToSharesReturn;
1945 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
1946 type ReturnToken<'a> = <Self::ReturnTuple<
1947 'a,
1948 > as alloy_sol_types::SolType>::Token<'a>;
1949 const SIGNATURE: &'static str = "underlyingToShares(uint256)";
1950 const SELECTOR: [u8; 4] = [140u8, 135u8, 16u8, 25u8];
1951 #[inline]
1952 fn new<'a>(
1953 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
1954 ) -> Self {
1955 tuple.into()
1956 }
1957 #[inline]
1958 fn tokenize(&self) -> Self::Token<'_> {
1959 (
1960 <alloy::sol_types::sol_data::Uint<
1961 256,
1962 > as alloy_sol_types::SolType>::tokenize(&self.amountUnderlying),
1963 )
1964 }
1965 #[inline]
1966 fn abi_decode_returns(
1967 data: &[u8],
1968 validate: bool,
1969 ) -> alloy_sol_types::Result<Self::Return> {
1970 <Self::ReturnTuple<
1971 '_,
1972 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
1973 .map(Into::into)
1974 }
1975 }
1976 };
1977 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1978 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1983 #[derive(Clone)]
1984 pub struct underlyingToSharesViewCall {
1985 #[allow(missing_docs)]
1986 pub amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
1987 }
1988 #[derive(Default, Debug, PartialEq, Eq, Hash)]
1989 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
1991 #[derive(Clone)]
1992 pub struct underlyingToSharesViewReturn {
1993 #[allow(missing_docs)]
1994 pub _0: alloy::sol_types::private::primitives::aliases::U256,
1995 }
1996 #[allow(
1997 non_camel_case_types,
1998 non_snake_case,
1999 clippy::pub_underscore_fields,
2000 clippy::style
2001 )]
2002 const _: () = {
2003 use alloy::sol_types as alloy_sol_types;
2004 {
2005 #[doc(hidden)]
2006 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2007 #[doc(hidden)]
2008 type UnderlyingRustTuple<'a> = (
2009 alloy::sol_types::private::primitives::aliases::U256,
2010 );
2011 #[cfg(test)]
2012 #[allow(dead_code, unreachable_patterns)]
2013 fn _type_assertion(
2014 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2015 ) {
2016 match _t {
2017 alloy_sol_types::private::AssertTypeEq::<
2018 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2019 >(_) => {}
2020 }
2021 }
2022 #[automatically_derived]
2023 #[doc(hidden)]
2024 impl ::core::convert::From<underlyingToSharesViewCall>
2025 for UnderlyingRustTuple<'_> {
2026 fn from(value: underlyingToSharesViewCall) -> Self {
2027 (value.amountUnderlying,)
2028 }
2029 }
2030 #[automatically_derived]
2031 #[doc(hidden)]
2032 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2033 for underlyingToSharesViewCall {
2034 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2035 Self { amountUnderlying: tuple.0 }
2036 }
2037 }
2038 }
2039 {
2040 #[doc(hidden)]
2041 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2042 #[doc(hidden)]
2043 type UnderlyingRustTuple<'a> = (
2044 alloy::sol_types::private::primitives::aliases::U256,
2045 );
2046 #[cfg(test)]
2047 #[allow(dead_code, unreachable_patterns)]
2048 fn _type_assertion(
2049 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2050 ) {
2051 match _t {
2052 alloy_sol_types::private::AssertTypeEq::<
2053 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2054 >(_) => {}
2055 }
2056 }
2057 #[automatically_derived]
2058 #[doc(hidden)]
2059 impl ::core::convert::From<underlyingToSharesViewReturn>
2060 for UnderlyingRustTuple<'_> {
2061 fn from(value: underlyingToSharesViewReturn) -> Self {
2062 (value._0,)
2063 }
2064 }
2065 #[automatically_derived]
2066 #[doc(hidden)]
2067 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2068 for underlyingToSharesViewReturn {
2069 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2070 Self { _0: tuple.0 }
2071 }
2072 }
2073 }
2074 #[automatically_derived]
2075 impl alloy_sol_types::SolCall for underlyingToSharesViewCall {
2076 type Parameters<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2077 type Token<'a> = <Self::Parameters<
2078 'a,
2079 > as alloy_sol_types::SolType>::Token<'a>;
2080 type Return = underlyingToSharesViewReturn;
2081 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2082 type ReturnToken<'a> = <Self::ReturnTuple<
2083 'a,
2084 > as alloy_sol_types::SolType>::Token<'a>;
2085 const SIGNATURE: &'static str = "underlyingToSharesView(uint256)";
2086 const SELECTOR: [u8; 4] = [227u8, 218u8, 229u8, 28u8];
2087 #[inline]
2088 fn new<'a>(
2089 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2090 ) -> Self {
2091 tuple.into()
2092 }
2093 #[inline]
2094 fn tokenize(&self) -> Self::Token<'_> {
2095 (
2096 <alloy::sol_types::sol_data::Uint<
2097 256,
2098 > as alloy_sol_types::SolType>::tokenize(&self.amountUnderlying),
2099 )
2100 }
2101 #[inline]
2102 fn abi_decode_returns(
2103 data: &[u8],
2104 validate: bool,
2105 ) -> alloy_sol_types::Result<Self::Return> {
2106 <Self::ReturnTuple<
2107 '_,
2108 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2109 .map(Into::into)
2110 }
2111 }
2112 };
2113 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2114 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2119 #[derive(Clone)]
2120 pub struct underlyingTokenCall {}
2121 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2122 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2124 #[derive(Clone)]
2125 pub struct underlyingTokenReturn {
2126 #[allow(missing_docs)]
2127 pub _0: alloy::sol_types::private::Address,
2128 }
2129 #[allow(
2130 non_camel_case_types,
2131 non_snake_case,
2132 clippy::pub_underscore_fields,
2133 clippy::style
2134 )]
2135 const _: () = {
2136 use alloy::sol_types as alloy_sol_types;
2137 {
2138 #[doc(hidden)]
2139 type UnderlyingSolTuple<'a> = ();
2140 #[doc(hidden)]
2141 type UnderlyingRustTuple<'a> = ();
2142 #[cfg(test)]
2143 #[allow(dead_code, unreachable_patterns)]
2144 fn _type_assertion(
2145 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2146 ) {
2147 match _t {
2148 alloy_sol_types::private::AssertTypeEq::<
2149 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2150 >(_) => {}
2151 }
2152 }
2153 #[automatically_derived]
2154 #[doc(hidden)]
2155 impl ::core::convert::From<underlyingTokenCall> for UnderlyingRustTuple<'_> {
2156 fn from(value: underlyingTokenCall) -> Self {
2157 ()
2158 }
2159 }
2160 #[automatically_derived]
2161 #[doc(hidden)]
2162 impl ::core::convert::From<UnderlyingRustTuple<'_>> for underlyingTokenCall {
2163 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2164 Self {}
2165 }
2166 }
2167 }
2168 {
2169 #[doc(hidden)]
2170 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2171 #[doc(hidden)]
2172 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2173 #[cfg(test)]
2174 #[allow(dead_code, unreachable_patterns)]
2175 fn _type_assertion(
2176 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2177 ) {
2178 match _t {
2179 alloy_sol_types::private::AssertTypeEq::<
2180 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2181 >(_) => {}
2182 }
2183 }
2184 #[automatically_derived]
2185 #[doc(hidden)]
2186 impl ::core::convert::From<underlyingTokenReturn>
2187 for UnderlyingRustTuple<'_> {
2188 fn from(value: underlyingTokenReturn) -> Self {
2189 (value._0,)
2190 }
2191 }
2192 #[automatically_derived]
2193 #[doc(hidden)]
2194 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2195 for underlyingTokenReturn {
2196 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2197 Self { _0: tuple.0 }
2198 }
2199 }
2200 }
2201 #[automatically_derived]
2202 impl alloy_sol_types::SolCall for underlyingTokenCall {
2203 type Parameters<'a> = ();
2204 type Token<'a> = <Self::Parameters<
2205 'a,
2206 > as alloy_sol_types::SolType>::Token<'a>;
2207 type Return = underlyingTokenReturn;
2208 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Address,);
2209 type ReturnToken<'a> = <Self::ReturnTuple<
2210 'a,
2211 > as alloy_sol_types::SolType>::Token<'a>;
2212 const SIGNATURE: &'static str = "underlyingToken()";
2213 const SELECTOR: [u8; 4] = [36u8, 149u8, 165u8, 153u8];
2214 #[inline]
2215 fn new<'a>(
2216 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2217 ) -> Self {
2218 tuple.into()
2219 }
2220 #[inline]
2221 fn tokenize(&self) -> Self::Token<'_> {
2222 ()
2223 }
2224 #[inline]
2225 fn abi_decode_returns(
2226 data: &[u8],
2227 validate: bool,
2228 ) -> alloy_sol_types::Result<Self::Return> {
2229 <Self::ReturnTuple<
2230 '_,
2231 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2232 .map(Into::into)
2233 }
2234 }
2235 };
2236 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2237 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2242 #[derive(Clone)]
2243 pub struct userUnderlyingCall {
2244 #[allow(missing_docs)]
2245 pub user: alloy::sol_types::private::Address,
2246 }
2247 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2248 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2250 #[derive(Clone)]
2251 pub struct userUnderlyingReturn {
2252 #[allow(missing_docs)]
2253 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2254 }
2255 #[allow(
2256 non_camel_case_types,
2257 non_snake_case,
2258 clippy::pub_underscore_fields,
2259 clippy::style
2260 )]
2261 const _: () = {
2262 use alloy::sol_types as alloy_sol_types;
2263 {
2264 #[doc(hidden)]
2265 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2266 #[doc(hidden)]
2267 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2268 #[cfg(test)]
2269 #[allow(dead_code, unreachable_patterns)]
2270 fn _type_assertion(
2271 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2272 ) {
2273 match _t {
2274 alloy_sol_types::private::AssertTypeEq::<
2275 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2276 >(_) => {}
2277 }
2278 }
2279 #[automatically_derived]
2280 #[doc(hidden)]
2281 impl ::core::convert::From<userUnderlyingCall> for UnderlyingRustTuple<'_> {
2282 fn from(value: userUnderlyingCall) -> Self {
2283 (value.user,)
2284 }
2285 }
2286 #[automatically_derived]
2287 #[doc(hidden)]
2288 impl ::core::convert::From<UnderlyingRustTuple<'_>> for userUnderlyingCall {
2289 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2290 Self { user: tuple.0 }
2291 }
2292 }
2293 }
2294 {
2295 #[doc(hidden)]
2296 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2297 #[doc(hidden)]
2298 type UnderlyingRustTuple<'a> = (
2299 alloy::sol_types::private::primitives::aliases::U256,
2300 );
2301 #[cfg(test)]
2302 #[allow(dead_code, unreachable_patterns)]
2303 fn _type_assertion(
2304 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2305 ) {
2306 match _t {
2307 alloy_sol_types::private::AssertTypeEq::<
2308 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2309 >(_) => {}
2310 }
2311 }
2312 #[automatically_derived]
2313 #[doc(hidden)]
2314 impl ::core::convert::From<userUnderlyingReturn>
2315 for UnderlyingRustTuple<'_> {
2316 fn from(value: userUnderlyingReturn) -> Self {
2317 (value._0,)
2318 }
2319 }
2320 #[automatically_derived]
2321 #[doc(hidden)]
2322 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2323 for userUnderlyingReturn {
2324 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2325 Self { _0: tuple.0 }
2326 }
2327 }
2328 }
2329 #[automatically_derived]
2330 impl alloy_sol_types::SolCall for userUnderlyingCall {
2331 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2332 type Token<'a> = <Self::Parameters<
2333 'a,
2334 > as alloy_sol_types::SolType>::Token<'a>;
2335 type Return = userUnderlyingReturn;
2336 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2337 type ReturnToken<'a> = <Self::ReturnTuple<
2338 'a,
2339 > as alloy_sol_types::SolType>::Token<'a>;
2340 const SIGNATURE: &'static str = "userUnderlying(address)";
2341 const SELECTOR: [u8; 4] = [143u8, 106u8, 98u8, 64u8];
2342 #[inline]
2343 fn new<'a>(
2344 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2345 ) -> Self {
2346 tuple.into()
2347 }
2348 #[inline]
2349 fn tokenize(&self) -> Self::Token<'_> {
2350 (
2351 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2352 &self.user,
2353 ),
2354 )
2355 }
2356 #[inline]
2357 fn abi_decode_returns(
2358 data: &[u8],
2359 validate: bool,
2360 ) -> alloy_sol_types::Result<Self::Return> {
2361 <Self::ReturnTuple<
2362 '_,
2363 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2364 .map(Into::into)
2365 }
2366 }
2367 };
2368 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2369 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2374 #[derive(Clone)]
2375 pub struct userUnderlyingViewCall {
2376 #[allow(missing_docs)]
2377 pub user: alloy::sol_types::private::Address,
2378 }
2379 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2380 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2382 #[derive(Clone)]
2383 pub struct userUnderlyingViewReturn {
2384 #[allow(missing_docs)]
2385 pub _0: alloy::sol_types::private::primitives::aliases::U256,
2386 }
2387 #[allow(
2388 non_camel_case_types,
2389 non_snake_case,
2390 clippy::pub_underscore_fields,
2391 clippy::style
2392 )]
2393 const _: () = {
2394 use alloy::sol_types as alloy_sol_types;
2395 {
2396 #[doc(hidden)]
2397 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Address,);
2398 #[doc(hidden)]
2399 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::Address,);
2400 #[cfg(test)]
2401 #[allow(dead_code, unreachable_patterns)]
2402 fn _type_assertion(
2403 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2404 ) {
2405 match _t {
2406 alloy_sol_types::private::AssertTypeEq::<
2407 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2408 >(_) => {}
2409 }
2410 }
2411 #[automatically_derived]
2412 #[doc(hidden)]
2413 impl ::core::convert::From<userUnderlyingViewCall>
2414 for UnderlyingRustTuple<'_> {
2415 fn from(value: userUnderlyingViewCall) -> Self {
2416 (value.user,)
2417 }
2418 }
2419 #[automatically_derived]
2420 #[doc(hidden)]
2421 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2422 for userUnderlyingViewCall {
2423 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2424 Self { user: tuple.0 }
2425 }
2426 }
2427 }
2428 {
2429 #[doc(hidden)]
2430 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2431 #[doc(hidden)]
2432 type UnderlyingRustTuple<'a> = (
2433 alloy::sol_types::private::primitives::aliases::U256,
2434 );
2435 #[cfg(test)]
2436 #[allow(dead_code, unreachable_patterns)]
2437 fn _type_assertion(
2438 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2439 ) {
2440 match _t {
2441 alloy_sol_types::private::AssertTypeEq::<
2442 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2443 >(_) => {}
2444 }
2445 }
2446 #[automatically_derived]
2447 #[doc(hidden)]
2448 impl ::core::convert::From<userUnderlyingViewReturn>
2449 for UnderlyingRustTuple<'_> {
2450 fn from(value: userUnderlyingViewReturn) -> Self {
2451 (value._0,)
2452 }
2453 }
2454 #[automatically_derived]
2455 #[doc(hidden)]
2456 impl ::core::convert::From<UnderlyingRustTuple<'_>>
2457 for userUnderlyingViewReturn {
2458 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2459 Self { _0: tuple.0 }
2460 }
2461 }
2462 }
2463 #[automatically_derived]
2464 impl alloy_sol_types::SolCall for userUnderlyingViewCall {
2465 type Parameters<'a> = (alloy::sol_types::sol_data::Address,);
2466 type Token<'a> = <Self::Parameters<
2467 'a,
2468 > as alloy_sol_types::SolType>::Token<'a>;
2469 type Return = userUnderlyingViewReturn;
2470 type ReturnTuple<'a> = (alloy::sol_types::sol_data::Uint<256>,);
2471 type ReturnToken<'a> = <Self::ReturnTuple<
2472 'a,
2473 > as alloy_sol_types::SolType>::Token<'a>;
2474 const SIGNATURE: &'static str = "userUnderlyingView(address)";
2475 const SELECTOR: [u8; 4] = [85u8, 60u8, 165u8, 248u8];
2476 #[inline]
2477 fn new<'a>(
2478 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2479 ) -> Self {
2480 tuple.into()
2481 }
2482 #[inline]
2483 fn tokenize(&self) -> Self::Token<'_> {
2484 (
2485 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2486 &self.user,
2487 ),
2488 )
2489 }
2490 #[inline]
2491 fn abi_decode_returns(
2492 data: &[u8],
2493 validate: bool,
2494 ) -> alloy_sol_types::Result<Self::Return> {
2495 <Self::ReturnTuple<
2496 '_,
2497 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2498 .map(Into::into)
2499 }
2500 }
2501 };
2502 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2503 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2508 #[derive(Clone)]
2509 pub struct versionCall {}
2510 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2511 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2513 #[derive(Clone)]
2514 pub struct versionReturn {
2515 #[allow(missing_docs)]
2516 pub _0: alloy::sol_types::private::String,
2517 }
2518 #[allow(
2519 non_camel_case_types,
2520 non_snake_case,
2521 clippy::pub_underscore_fields,
2522 clippy::style
2523 )]
2524 const _: () = {
2525 use alloy::sol_types as alloy_sol_types;
2526 {
2527 #[doc(hidden)]
2528 type UnderlyingSolTuple<'a> = ();
2529 #[doc(hidden)]
2530 type UnderlyingRustTuple<'a> = ();
2531 #[cfg(test)]
2532 #[allow(dead_code, unreachable_patterns)]
2533 fn _type_assertion(
2534 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2535 ) {
2536 match _t {
2537 alloy_sol_types::private::AssertTypeEq::<
2538 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2539 >(_) => {}
2540 }
2541 }
2542 #[automatically_derived]
2543 #[doc(hidden)]
2544 impl ::core::convert::From<versionCall> for UnderlyingRustTuple<'_> {
2545 fn from(value: versionCall) -> Self {
2546 ()
2547 }
2548 }
2549 #[automatically_derived]
2550 #[doc(hidden)]
2551 impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionCall {
2552 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2553 Self {}
2554 }
2555 }
2556 }
2557 {
2558 #[doc(hidden)]
2559 type UnderlyingSolTuple<'a> = (alloy::sol_types::sol_data::String,);
2560 #[doc(hidden)]
2561 type UnderlyingRustTuple<'a> = (alloy::sol_types::private::String,);
2562 #[cfg(test)]
2563 #[allow(dead_code, unreachable_patterns)]
2564 fn _type_assertion(
2565 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2566 ) {
2567 match _t {
2568 alloy_sol_types::private::AssertTypeEq::<
2569 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2570 >(_) => {}
2571 }
2572 }
2573 #[automatically_derived]
2574 #[doc(hidden)]
2575 impl ::core::convert::From<versionReturn> for UnderlyingRustTuple<'_> {
2576 fn from(value: versionReturn) -> Self {
2577 (value._0,)
2578 }
2579 }
2580 #[automatically_derived]
2581 #[doc(hidden)]
2582 impl ::core::convert::From<UnderlyingRustTuple<'_>> for versionReturn {
2583 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2584 Self { _0: tuple.0 }
2585 }
2586 }
2587 }
2588 #[automatically_derived]
2589 impl alloy_sol_types::SolCall for versionCall {
2590 type Parameters<'a> = ();
2591 type Token<'a> = <Self::Parameters<
2592 'a,
2593 > as alloy_sol_types::SolType>::Token<'a>;
2594 type Return = versionReturn;
2595 type ReturnTuple<'a> = (alloy::sol_types::sol_data::String,);
2596 type ReturnToken<'a> = <Self::ReturnTuple<
2597 'a,
2598 > as alloy_sol_types::SolType>::Token<'a>;
2599 const SIGNATURE: &'static str = "version()";
2600 const SELECTOR: [u8; 4] = [84u8, 253u8, 77u8, 80u8];
2601 #[inline]
2602 fn new<'a>(
2603 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2604 ) -> Self {
2605 tuple.into()
2606 }
2607 #[inline]
2608 fn tokenize(&self) -> Self::Token<'_> {
2609 ()
2610 }
2611 #[inline]
2612 fn abi_decode_returns(
2613 data: &[u8],
2614 validate: bool,
2615 ) -> alloy_sol_types::Result<Self::Return> {
2616 <Self::ReturnTuple<
2617 '_,
2618 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2619 .map(Into::into)
2620 }
2621 }
2622 };
2623 #[derive(Default, Debug, PartialEq, Eq, Hash)]
2624 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2629 #[derive(Clone)]
2630 pub struct withdrawCall {
2631 #[allow(missing_docs)]
2632 pub recipient: alloy::sol_types::private::Address,
2633 #[allow(missing_docs)]
2634 pub token: alloy::sol_types::private::Address,
2635 #[allow(missing_docs)]
2636 pub amountShares: alloy::sol_types::private::primitives::aliases::U256,
2637 }
2638 #[allow(non_camel_case_types, non_snake_case, clippy::pub_underscore_fields)]
2640 #[derive(Clone)]
2641 pub struct withdrawReturn {}
2642 #[allow(
2643 non_camel_case_types,
2644 non_snake_case,
2645 clippy::pub_underscore_fields,
2646 clippy::style
2647 )]
2648 const _: () = {
2649 use alloy::sol_types as alloy_sol_types;
2650 {
2651 #[doc(hidden)]
2652 type UnderlyingSolTuple<'a> = (
2653 alloy::sol_types::sol_data::Address,
2654 alloy::sol_types::sol_data::Address,
2655 alloy::sol_types::sol_data::Uint<256>,
2656 );
2657 #[doc(hidden)]
2658 type UnderlyingRustTuple<'a> = (
2659 alloy::sol_types::private::Address,
2660 alloy::sol_types::private::Address,
2661 alloy::sol_types::private::primitives::aliases::U256,
2662 );
2663 #[cfg(test)]
2664 #[allow(dead_code, unreachable_patterns)]
2665 fn _type_assertion(
2666 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2667 ) {
2668 match _t {
2669 alloy_sol_types::private::AssertTypeEq::<
2670 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2671 >(_) => {}
2672 }
2673 }
2674 #[automatically_derived]
2675 #[doc(hidden)]
2676 impl ::core::convert::From<withdrawCall> for UnderlyingRustTuple<'_> {
2677 fn from(value: withdrawCall) -> Self {
2678 (value.recipient, value.token, value.amountShares)
2679 }
2680 }
2681 #[automatically_derived]
2682 #[doc(hidden)]
2683 impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawCall {
2684 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2685 Self {
2686 recipient: tuple.0,
2687 token: tuple.1,
2688 amountShares: tuple.2,
2689 }
2690 }
2691 }
2692 }
2693 {
2694 #[doc(hidden)]
2695 type UnderlyingSolTuple<'a> = ();
2696 #[doc(hidden)]
2697 type UnderlyingRustTuple<'a> = ();
2698 #[cfg(test)]
2699 #[allow(dead_code, unreachable_patterns)]
2700 fn _type_assertion(
2701 _t: alloy_sol_types::private::AssertTypeEq<UnderlyingRustTuple>,
2702 ) {
2703 match _t {
2704 alloy_sol_types::private::AssertTypeEq::<
2705 <UnderlyingSolTuple as alloy_sol_types::SolType>::RustType,
2706 >(_) => {}
2707 }
2708 }
2709 #[automatically_derived]
2710 #[doc(hidden)]
2711 impl ::core::convert::From<withdrawReturn> for UnderlyingRustTuple<'_> {
2712 fn from(value: withdrawReturn) -> Self {
2713 ()
2714 }
2715 }
2716 #[automatically_derived]
2717 #[doc(hidden)]
2718 impl ::core::convert::From<UnderlyingRustTuple<'_>> for withdrawReturn {
2719 fn from(tuple: UnderlyingRustTuple<'_>) -> Self {
2720 Self {}
2721 }
2722 }
2723 }
2724 #[automatically_derived]
2725 impl alloy_sol_types::SolCall for withdrawCall {
2726 type Parameters<'a> = (
2727 alloy::sol_types::sol_data::Address,
2728 alloy::sol_types::sol_data::Address,
2729 alloy::sol_types::sol_data::Uint<256>,
2730 );
2731 type Token<'a> = <Self::Parameters<
2732 'a,
2733 > as alloy_sol_types::SolType>::Token<'a>;
2734 type Return = withdrawReturn;
2735 type ReturnTuple<'a> = ();
2736 type ReturnToken<'a> = <Self::ReturnTuple<
2737 'a,
2738 > as alloy_sol_types::SolType>::Token<'a>;
2739 const SIGNATURE: &'static str = "withdraw(address,address,uint256)";
2740 const SELECTOR: [u8; 4] = [217u8, 202u8, 237u8, 18u8];
2741 #[inline]
2742 fn new<'a>(
2743 tuple: <Self::Parameters<'a> as alloy_sol_types::SolType>::RustType,
2744 ) -> Self {
2745 tuple.into()
2746 }
2747 #[inline]
2748 fn tokenize(&self) -> Self::Token<'_> {
2749 (
2750 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2751 &self.recipient,
2752 ),
2753 <alloy::sol_types::sol_data::Address as alloy_sol_types::SolType>::tokenize(
2754 &self.token,
2755 ),
2756 <alloy::sol_types::sol_data::Uint<
2757 256,
2758 > as alloy_sol_types::SolType>::tokenize(&self.amountShares),
2759 )
2760 }
2761 #[inline]
2762 fn abi_decode_returns(
2763 data: &[u8],
2764 validate: bool,
2765 ) -> alloy_sol_types::Result<Self::Return> {
2766 <Self::ReturnTuple<
2767 '_,
2768 > as alloy_sol_types::SolType>::abi_decode_sequence(data, validate)
2769 .map(Into::into)
2770 }
2771 }
2772 };
2773 #[derive()]
2775 pub enum IStrategyCalls {
2776 #[allow(missing_docs)]
2777 deposit(depositCall),
2778 #[allow(missing_docs)]
2779 explanation(explanationCall),
2780 #[allow(missing_docs)]
2781 shares(sharesCall),
2782 #[allow(missing_docs)]
2783 sharesToUnderlying(sharesToUnderlyingCall),
2784 #[allow(missing_docs)]
2785 sharesToUnderlyingView(sharesToUnderlyingViewCall),
2786 #[allow(missing_docs)]
2787 totalShares(totalSharesCall),
2788 #[allow(missing_docs)]
2789 underlyingToShares(underlyingToSharesCall),
2790 #[allow(missing_docs)]
2791 underlyingToSharesView(underlyingToSharesViewCall),
2792 #[allow(missing_docs)]
2793 underlyingToken(underlyingTokenCall),
2794 #[allow(missing_docs)]
2795 userUnderlying(userUnderlyingCall),
2796 #[allow(missing_docs)]
2797 userUnderlyingView(userUnderlyingViewCall),
2798 #[allow(missing_docs)]
2799 version(versionCall),
2800 #[allow(missing_docs)]
2801 withdraw(withdrawCall),
2802 }
2803 #[automatically_derived]
2804 impl IStrategyCalls {
2805 pub const SELECTORS: &'static [[u8; 4usize]] = &[
2812 [36u8, 149u8, 165u8, 153u8],
2813 [58u8, 152u8, 239u8, 57u8],
2814 [71u8, 231u8, 239u8, 36u8],
2815 [84u8, 253u8, 77u8, 80u8],
2816 [85u8, 60u8, 165u8, 248u8],
2817 [122u8, 139u8, 38u8, 55u8],
2818 [140u8, 135u8, 16u8, 25u8],
2819 [143u8, 106u8, 98u8, 64u8],
2820 [171u8, 89u8, 33u8, 225u8],
2821 [206u8, 124u8, 42u8, 194u8],
2822 [217u8, 202u8, 237u8, 18u8],
2823 [227u8, 218u8, 229u8, 28u8],
2824 [243u8, 231u8, 56u8, 117u8],
2825 ];
2826 }
2827 #[automatically_derived]
2828 impl alloy_sol_types::SolInterface for IStrategyCalls {
2829 const NAME: &'static str = "IStrategyCalls";
2830 const MIN_DATA_LENGTH: usize = 0usize;
2831 const COUNT: usize = 13usize;
2832 #[inline]
2833 fn selector(&self) -> [u8; 4] {
2834 match self {
2835 Self::deposit(_) => <depositCall as alloy_sol_types::SolCall>::SELECTOR,
2836 Self::explanation(_) => {
2837 <explanationCall as alloy_sol_types::SolCall>::SELECTOR
2838 }
2839 Self::shares(_) => <sharesCall as alloy_sol_types::SolCall>::SELECTOR,
2840 Self::sharesToUnderlying(_) => {
2841 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::SELECTOR
2842 }
2843 Self::sharesToUnderlyingView(_) => {
2844 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::SELECTOR
2845 }
2846 Self::totalShares(_) => {
2847 <totalSharesCall as alloy_sol_types::SolCall>::SELECTOR
2848 }
2849 Self::underlyingToShares(_) => {
2850 <underlyingToSharesCall as alloy_sol_types::SolCall>::SELECTOR
2851 }
2852 Self::underlyingToSharesView(_) => {
2853 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::SELECTOR
2854 }
2855 Self::underlyingToken(_) => {
2856 <underlyingTokenCall as alloy_sol_types::SolCall>::SELECTOR
2857 }
2858 Self::userUnderlying(_) => {
2859 <userUnderlyingCall as alloy_sol_types::SolCall>::SELECTOR
2860 }
2861 Self::userUnderlyingView(_) => {
2862 <userUnderlyingViewCall as alloy_sol_types::SolCall>::SELECTOR
2863 }
2864 Self::version(_) => <versionCall as alloy_sol_types::SolCall>::SELECTOR,
2865 Self::withdraw(_) => <withdrawCall as alloy_sol_types::SolCall>::SELECTOR,
2866 }
2867 }
2868 #[inline]
2869 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
2870 Self::SELECTORS.get(i).copied()
2871 }
2872 #[inline]
2873 fn valid_selector(selector: [u8; 4]) -> bool {
2874 Self::SELECTORS.binary_search(&selector).is_ok()
2875 }
2876 #[inline]
2877 #[allow(non_snake_case)]
2878 fn abi_decode_raw(
2879 selector: [u8; 4],
2880 data: &[u8],
2881 validate: bool,
2882 ) -> alloy_sol_types::Result<Self> {
2883 static DECODE_SHIMS: &[fn(
2884 &[u8],
2885 bool,
2886 ) -> alloy_sol_types::Result<IStrategyCalls>] = &[
2887 {
2888 fn underlyingToken(
2889 data: &[u8],
2890 validate: bool,
2891 ) -> alloy_sol_types::Result<IStrategyCalls> {
2892 <underlyingTokenCall as alloy_sol_types::SolCall>::abi_decode_raw(
2893 data,
2894 validate,
2895 )
2896 .map(IStrategyCalls::underlyingToken)
2897 }
2898 underlyingToken
2899 },
2900 {
2901 fn totalShares(
2902 data: &[u8],
2903 validate: bool,
2904 ) -> alloy_sol_types::Result<IStrategyCalls> {
2905 <totalSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(
2906 data,
2907 validate,
2908 )
2909 .map(IStrategyCalls::totalShares)
2910 }
2911 totalShares
2912 },
2913 {
2914 fn deposit(
2915 data: &[u8],
2916 validate: bool,
2917 ) -> alloy_sol_types::Result<IStrategyCalls> {
2918 <depositCall as alloy_sol_types::SolCall>::abi_decode_raw(
2919 data,
2920 validate,
2921 )
2922 .map(IStrategyCalls::deposit)
2923 }
2924 deposit
2925 },
2926 {
2927 fn version(
2928 data: &[u8],
2929 validate: bool,
2930 ) -> alloy_sol_types::Result<IStrategyCalls> {
2931 <versionCall as alloy_sol_types::SolCall>::abi_decode_raw(
2932 data,
2933 validate,
2934 )
2935 .map(IStrategyCalls::version)
2936 }
2937 version
2938 },
2939 {
2940 fn userUnderlyingView(
2941 data: &[u8],
2942 validate: bool,
2943 ) -> alloy_sol_types::Result<IStrategyCalls> {
2944 <userUnderlyingViewCall as alloy_sol_types::SolCall>::abi_decode_raw(
2945 data,
2946 validate,
2947 )
2948 .map(IStrategyCalls::userUnderlyingView)
2949 }
2950 userUnderlyingView
2951 },
2952 {
2953 fn sharesToUnderlyingView(
2954 data: &[u8],
2955 validate: bool,
2956 ) -> alloy_sol_types::Result<IStrategyCalls> {
2957 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::abi_decode_raw(
2958 data,
2959 validate,
2960 )
2961 .map(IStrategyCalls::sharesToUnderlyingView)
2962 }
2963 sharesToUnderlyingView
2964 },
2965 {
2966 fn underlyingToShares(
2967 data: &[u8],
2968 validate: bool,
2969 ) -> alloy_sol_types::Result<IStrategyCalls> {
2970 <underlyingToSharesCall as alloy_sol_types::SolCall>::abi_decode_raw(
2971 data,
2972 validate,
2973 )
2974 .map(IStrategyCalls::underlyingToShares)
2975 }
2976 underlyingToShares
2977 },
2978 {
2979 fn userUnderlying(
2980 data: &[u8],
2981 validate: bool,
2982 ) -> alloy_sol_types::Result<IStrategyCalls> {
2983 <userUnderlyingCall as alloy_sol_types::SolCall>::abi_decode_raw(
2984 data,
2985 validate,
2986 )
2987 .map(IStrategyCalls::userUnderlying)
2988 }
2989 userUnderlying
2990 },
2991 {
2992 fn explanation(
2993 data: &[u8],
2994 validate: bool,
2995 ) -> alloy_sol_types::Result<IStrategyCalls> {
2996 <explanationCall as alloy_sol_types::SolCall>::abi_decode_raw(
2997 data,
2998 validate,
2999 )
3000 .map(IStrategyCalls::explanation)
3001 }
3002 explanation
3003 },
3004 {
3005 fn shares(
3006 data: &[u8],
3007 validate: bool,
3008 ) -> alloy_sol_types::Result<IStrategyCalls> {
3009 <sharesCall as alloy_sol_types::SolCall>::abi_decode_raw(
3010 data,
3011 validate,
3012 )
3013 .map(IStrategyCalls::shares)
3014 }
3015 shares
3016 },
3017 {
3018 fn withdraw(
3019 data: &[u8],
3020 validate: bool,
3021 ) -> alloy_sol_types::Result<IStrategyCalls> {
3022 <withdrawCall as alloy_sol_types::SolCall>::abi_decode_raw(
3023 data,
3024 validate,
3025 )
3026 .map(IStrategyCalls::withdraw)
3027 }
3028 withdraw
3029 },
3030 {
3031 fn underlyingToSharesView(
3032 data: &[u8],
3033 validate: bool,
3034 ) -> alloy_sol_types::Result<IStrategyCalls> {
3035 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::abi_decode_raw(
3036 data,
3037 validate,
3038 )
3039 .map(IStrategyCalls::underlyingToSharesView)
3040 }
3041 underlyingToSharesView
3042 },
3043 {
3044 fn sharesToUnderlying(
3045 data: &[u8],
3046 validate: bool,
3047 ) -> alloy_sol_types::Result<IStrategyCalls> {
3048 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::abi_decode_raw(
3049 data,
3050 validate,
3051 )
3052 .map(IStrategyCalls::sharesToUnderlying)
3053 }
3054 sharesToUnderlying
3055 },
3056 ];
3057 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3058 return Err(
3059 alloy_sol_types::Error::unknown_selector(
3060 <Self as alloy_sol_types::SolInterface>::NAME,
3061 selector,
3062 ),
3063 );
3064 };
3065 DECODE_SHIMS[idx](data, validate)
3066 }
3067 #[inline]
3068 fn abi_encoded_size(&self) -> usize {
3069 match self {
3070 Self::deposit(inner) => {
3071 <depositCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
3072 }
3073 Self::explanation(inner) => {
3074 <explanationCall as alloy_sol_types::SolCall>::abi_encoded_size(
3075 inner,
3076 )
3077 }
3078 Self::shares(inner) => {
3079 <sharesCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
3080 }
3081 Self::sharesToUnderlying(inner) => {
3082 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::abi_encoded_size(
3083 inner,
3084 )
3085 }
3086 Self::sharesToUnderlyingView(inner) => {
3087 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encoded_size(
3088 inner,
3089 )
3090 }
3091 Self::totalShares(inner) => {
3092 <totalSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
3093 inner,
3094 )
3095 }
3096 Self::underlyingToShares(inner) => {
3097 <underlyingToSharesCall as alloy_sol_types::SolCall>::abi_encoded_size(
3098 inner,
3099 )
3100 }
3101 Self::underlyingToSharesView(inner) => {
3102 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::abi_encoded_size(
3103 inner,
3104 )
3105 }
3106 Self::underlyingToken(inner) => {
3107 <underlyingTokenCall as alloy_sol_types::SolCall>::abi_encoded_size(
3108 inner,
3109 )
3110 }
3111 Self::userUnderlying(inner) => {
3112 <userUnderlyingCall as alloy_sol_types::SolCall>::abi_encoded_size(
3113 inner,
3114 )
3115 }
3116 Self::userUnderlyingView(inner) => {
3117 <userUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encoded_size(
3118 inner,
3119 )
3120 }
3121 Self::version(inner) => {
3122 <versionCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
3123 }
3124 Self::withdraw(inner) => {
3125 <withdrawCall as alloy_sol_types::SolCall>::abi_encoded_size(inner)
3126 }
3127 }
3128 }
3129 #[inline]
3130 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
3131 match self {
3132 Self::deposit(inner) => {
3133 <depositCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
3134 }
3135 Self::explanation(inner) => {
3136 <explanationCall as alloy_sol_types::SolCall>::abi_encode_raw(
3137 inner,
3138 out,
3139 )
3140 }
3141 Self::shares(inner) => {
3142 <sharesCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
3143 }
3144 Self::sharesToUnderlying(inner) => {
3145 <sharesToUnderlyingCall as alloy_sol_types::SolCall>::abi_encode_raw(
3146 inner,
3147 out,
3148 )
3149 }
3150 Self::sharesToUnderlyingView(inner) => {
3151 <sharesToUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encode_raw(
3152 inner,
3153 out,
3154 )
3155 }
3156 Self::totalShares(inner) => {
3157 <totalSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
3158 inner,
3159 out,
3160 )
3161 }
3162 Self::underlyingToShares(inner) => {
3163 <underlyingToSharesCall as alloy_sol_types::SolCall>::abi_encode_raw(
3164 inner,
3165 out,
3166 )
3167 }
3168 Self::underlyingToSharesView(inner) => {
3169 <underlyingToSharesViewCall as alloy_sol_types::SolCall>::abi_encode_raw(
3170 inner,
3171 out,
3172 )
3173 }
3174 Self::underlyingToken(inner) => {
3175 <underlyingTokenCall as alloy_sol_types::SolCall>::abi_encode_raw(
3176 inner,
3177 out,
3178 )
3179 }
3180 Self::userUnderlying(inner) => {
3181 <userUnderlyingCall as alloy_sol_types::SolCall>::abi_encode_raw(
3182 inner,
3183 out,
3184 )
3185 }
3186 Self::userUnderlyingView(inner) => {
3187 <userUnderlyingViewCall as alloy_sol_types::SolCall>::abi_encode_raw(
3188 inner,
3189 out,
3190 )
3191 }
3192 Self::version(inner) => {
3193 <versionCall as alloy_sol_types::SolCall>::abi_encode_raw(inner, out)
3194 }
3195 Self::withdraw(inner) => {
3196 <withdrawCall as alloy_sol_types::SolCall>::abi_encode_raw(
3197 inner,
3198 out,
3199 )
3200 }
3201 }
3202 }
3203 }
3204 #[derive(Debug, PartialEq, Eq, Hash)]
3206 pub enum IStrategyErrors {
3207 #[allow(missing_docs)]
3208 BalanceExceedsMaxTotalDeposits(BalanceExceedsMaxTotalDeposits),
3209 #[allow(missing_docs)]
3210 MaxPerDepositExceedsMax(MaxPerDepositExceedsMax),
3211 #[allow(missing_docs)]
3212 NewSharesZero(NewSharesZero),
3213 #[allow(missing_docs)]
3214 OnlyStrategyManager(OnlyStrategyManager),
3215 #[allow(missing_docs)]
3216 OnlyUnderlyingToken(OnlyUnderlyingToken),
3217 #[allow(missing_docs)]
3218 TotalSharesExceedsMax(TotalSharesExceedsMax),
3219 #[allow(missing_docs)]
3220 WithdrawalAmountExceedsTotalDeposits(WithdrawalAmountExceedsTotalDeposits),
3221 }
3222 #[automatically_derived]
3223 impl IStrategyErrors {
3224 pub const SELECTORS: &'static [[u8; 4usize]] = &[
3231 [20u8, 172u8, 30u8, 220u8],
3232 [24u8, 114u8, 93u8, 166u8],
3233 [72u8, 218u8, 113u8, 79u8],
3234 [94u8, 41u8, 209u8, 70u8],
3235 [180u8, 105u8, 223u8, 48u8],
3236 [196u8, 170u8, 247u8, 64u8],
3237 [216u8, 107u8, 174u8, 103u8],
3238 ];
3239 }
3240 #[automatically_derived]
3241 impl alloy_sol_types::SolInterface for IStrategyErrors {
3242 const NAME: &'static str = "IStrategyErrors";
3243 const MIN_DATA_LENGTH: usize = 0usize;
3244 const COUNT: usize = 7usize;
3245 #[inline]
3246 fn selector(&self) -> [u8; 4] {
3247 match self {
3248 Self::BalanceExceedsMaxTotalDeposits(_) => {
3249 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::SELECTOR
3250 }
3251 Self::MaxPerDepositExceedsMax(_) => {
3252 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::SELECTOR
3253 }
3254 Self::NewSharesZero(_) => {
3255 <NewSharesZero as alloy_sol_types::SolError>::SELECTOR
3256 }
3257 Self::OnlyStrategyManager(_) => {
3258 <OnlyStrategyManager as alloy_sol_types::SolError>::SELECTOR
3259 }
3260 Self::OnlyUnderlyingToken(_) => {
3261 <OnlyUnderlyingToken as alloy_sol_types::SolError>::SELECTOR
3262 }
3263 Self::TotalSharesExceedsMax(_) => {
3264 <TotalSharesExceedsMax as alloy_sol_types::SolError>::SELECTOR
3265 }
3266 Self::WithdrawalAmountExceedsTotalDeposits(_) => {
3267 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::SELECTOR
3268 }
3269 }
3270 }
3271 #[inline]
3272 fn selector_at(i: usize) -> ::core::option::Option<[u8; 4]> {
3273 Self::SELECTORS.get(i).copied()
3274 }
3275 #[inline]
3276 fn valid_selector(selector: [u8; 4]) -> bool {
3277 Self::SELECTORS.binary_search(&selector).is_ok()
3278 }
3279 #[inline]
3280 #[allow(non_snake_case)]
3281 fn abi_decode_raw(
3282 selector: [u8; 4],
3283 data: &[u8],
3284 validate: bool,
3285 ) -> alloy_sol_types::Result<Self> {
3286 static DECODE_SHIMS: &[fn(
3287 &[u8],
3288 bool,
3289 ) -> alloy_sol_types::Result<IStrategyErrors>] = &[
3290 {
3291 fn MaxPerDepositExceedsMax(
3292 data: &[u8],
3293 validate: bool,
3294 ) -> alloy_sol_types::Result<IStrategyErrors> {
3295 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::abi_decode_raw(
3296 data,
3297 validate,
3298 )
3299 .map(IStrategyErrors::MaxPerDepositExceedsMax)
3300 }
3301 MaxPerDepositExceedsMax
3302 },
3303 {
3304 fn NewSharesZero(
3305 data: &[u8],
3306 validate: bool,
3307 ) -> alloy_sol_types::Result<IStrategyErrors> {
3308 <NewSharesZero as alloy_sol_types::SolError>::abi_decode_raw(
3309 data,
3310 validate,
3311 )
3312 .map(IStrategyErrors::NewSharesZero)
3313 }
3314 NewSharesZero
3315 },
3316 {
3317 fn OnlyStrategyManager(
3318 data: &[u8],
3319 validate: bool,
3320 ) -> alloy_sol_types::Result<IStrategyErrors> {
3321 <OnlyStrategyManager as alloy_sol_types::SolError>::abi_decode_raw(
3322 data,
3323 validate,
3324 )
3325 .map(IStrategyErrors::OnlyStrategyManager)
3326 }
3327 OnlyStrategyManager
3328 },
3329 {
3330 fn TotalSharesExceedsMax(
3331 data: &[u8],
3332 validate: bool,
3333 ) -> alloy_sol_types::Result<IStrategyErrors> {
3334 <TotalSharesExceedsMax as alloy_sol_types::SolError>::abi_decode_raw(
3335 data,
3336 validate,
3337 )
3338 .map(IStrategyErrors::TotalSharesExceedsMax)
3339 }
3340 TotalSharesExceedsMax
3341 },
3342 {
3343 fn WithdrawalAmountExceedsTotalDeposits(
3344 data: &[u8],
3345 validate: bool,
3346 ) -> alloy_sol_types::Result<IStrategyErrors> {
3347 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::abi_decode_raw(
3348 data,
3349 validate,
3350 )
3351 .map(IStrategyErrors::WithdrawalAmountExceedsTotalDeposits)
3352 }
3353 WithdrawalAmountExceedsTotalDeposits
3354 },
3355 {
3356 fn OnlyUnderlyingToken(
3357 data: &[u8],
3358 validate: bool,
3359 ) -> alloy_sol_types::Result<IStrategyErrors> {
3360 <OnlyUnderlyingToken as alloy_sol_types::SolError>::abi_decode_raw(
3361 data,
3362 validate,
3363 )
3364 .map(IStrategyErrors::OnlyUnderlyingToken)
3365 }
3366 OnlyUnderlyingToken
3367 },
3368 {
3369 fn BalanceExceedsMaxTotalDeposits(
3370 data: &[u8],
3371 validate: bool,
3372 ) -> alloy_sol_types::Result<IStrategyErrors> {
3373 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::abi_decode_raw(
3374 data,
3375 validate,
3376 )
3377 .map(IStrategyErrors::BalanceExceedsMaxTotalDeposits)
3378 }
3379 BalanceExceedsMaxTotalDeposits
3380 },
3381 ];
3382 let Ok(idx) = Self::SELECTORS.binary_search(&selector) else {
3383 return Err(
3384 alloy_sol_types::Error::unknown_selector(
3385 <Self as alloy_sol_types::SolInterface>::NAME,
3386 selector,
3387 ),
3388 );
3389 };
3390 DECODE_SHIMS[idx](data, validate)
3391 }
3392 #[inline]
3393 fn abi_encoded_size(&self) -> usize {
3394 match self {
3395 Self::BalanceExceedsMaxTotalDeposits(inner) => {
3396 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::abi_encoded_size(
3397 inner,
3398 )
3399 }
3400 Self::MaxPerDepositExceedsMax(inner) => {
3401 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::abi_encoded_size(
3402 inner,
3403 )
3404 }
3405 Self::NewSharesZero(inner) => {
3406 <NewSharesZero as alloy_sol_types::SolError>::abi_encoded_size(inner)
3407 }
3408 Self::OnlyStrategyManager(inner) => {
3409 <OnlyStrategyManager as alloy_sol_types::SolError>::abi_encoded_size(
3410 inner,
3411 )
3412 }
3413 Self::OnlyUnderlyingToken(inner) => {
3414 <OnlyUnderlyingToken as alloy_sol_types::SolError>::abi_encoded_size(
3415 inner,
3416 )
3417 }
3418 Self::TotalSharesExceedsMax(inner) => {
3419 <TotalSharesExceedsMax as alloy_sol_types::SolError>::abi_encoded_size(
3420 inner,
3421 )
3422 }
3423 Self::WithdrawalAmountExceedsTotalDeposits(inner) => {
3424 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::abi_encoded_size(
3425 inner,
3426 )
3427 }
3428 }
3429 }
3430 #[inline]
3431 fn abi_encode_raw(&self, out: &mut alloy_sol_types::private::Vec<u8>) {
3432 match self {
3433 Self::BalanceExceedsMaxTotalDeposits(inner) => {
3434 <BalanceExceedsMaxTotalDeposits as alloy_sol_types::SolError>::abi_encode_raw(
3435 inner,
3436 out,
3437 )
3438 }
3439 Self::MaxPerDepositExceedsMax(inner) => {
3440 <MaxPerDepositExceedsMax as alloy_sol_types::SolError>::abi_encode_raw(
3441 inner,
3442 out,
3443 )
3444 }
3445 Self::NewSharesZero(inner) => {
3446 <NewSharesZero as alloy_sol_types::SolError>::abi_encode_raw(
3447 inner,
3448 out,
3449 )
3450 }
3451 Self::OnlyStrategyManager(inner) => {
3452 <OnlyStrategyManager as alloy_sol_types::SolError>::abi_encode_raw(
3453 inner,
3454 out,
3455 )
3456 }
3457 Self::OnlyUnderlyingToken(inner) => {
3458 <OnlyUnderlyingToken as alloy_sol_types::SolError>::abi_encode_raw(
3459 inner,
3460 out,
3461 )
3462 }
3463 Self::TotalSharesExceedsMax(inner) => {
3464 <TotalSharesExceedsMax as alloy_sol_types::SolError>::abi_encode_raw(
3465 inner,
3466 out,
3467 )
3468 }
3469 Self::WithdrawalAmountExceedsTotalDeposits(inner) => {
3470 <WithdrawalAmountExceedsTotalDeposits as alloy_sol_types::SolError>::abi_encode_raw(
3471 inner,
3472 out,
3473 )
3474 }
3475 }
3476 }
3477 }
3478 #[derive(Debug, PartialEq, Eq, Hash)]
3480 pub enum IStrategyEvents {
3481 #[allow(missing_docs)]
3482 ExchangeRateEmitted(ExchangeRateEmitted),
3483 #[allow(missing_docs)]
3484 StrategyTokenSet(StrategyTokenSet),
3485 }
3486 #[automatically_derived]
3487 impl IStrategyEvents {
3488 pub const SELECTORS: &'static [[u8; 32usize]] = &[
3495 [
3496 28u8, 84u8, 7u8, 7u8, 176u8, 14u8, 181u8, 66u8, 123u8, 107u8, 119u8,
3497 79u8, 199u8, 153u8, 215u8, 86u8, 81u8, 106u8, 84u8, 174u8, 225u8, 8u8,
3498 182u8, 75u8, 50u8, 122u8, 204u8, 85u8, 175u8, 85u8, 117u8, 7u8,
3499 ],
3500 [
3501 210u8, 73u8, 79u8, 52u8, 121u8, 229u8, 218u8, 73u8, 211u8, 134u8, 101u8,
3502 124u8, 41u8, 44u8, 97u8, 11u8, 91u8, 1u8, 223u8, 49u8, 61u8, 7u8, 198u8,
3503 46u8, 176u8, 207u8, 164u8, 153u8, 36u8, 163u8, 27u8, 232u8,
3504 ],
3505 ];
3506 }
3507 #[automatically_derived]
3508 impl alloy_sol_types::SolEventInterface for IStrategyEvents {
3509 const NAME: &'static str = "IStrategyEvents";
3510 const COUNT: usize = 2usize;
3511 fn decode_raw_log(
3512 topics: &[alloy_sol_types::Word],
3513 data: &[u8],
3514 validate: bool,
3515 ) -> alloy_sol_types::Result<Self> {
3516 match topics.first().copied() {
3517 Some(
3518 <ExchangeRateEmitted as alloy_sol_types::SolEvent>::SIGNATURE_HASH,
3519 ) => {
3520 <ExchangeRateEmitted as alloy_sol_types::SolEvent>::decode_raw_log(
3521 topics,
3522 data,
3523 validate,
3524 )
3525 .map(Self::ExchangeRateEmitted)
3526 }
3527 Some(<StrategyTokenSet as alloy_sol_types::SolEvent>::SIGNATURE_HASH) => {
3528 <StrategyTokenSet as alloy_sol_types::SolEvent>::decode_raw_log(
3529 topics,
3530 data,
3531 validate,
3532 )
3533 .map(Self::StrategyTokenSet)
3534 }
3535 _ => {
3536 alloy_sol_types::private::Err(alloy_sol_types::Error::InvalidLog {
3537 name: <Self as alloy_sol_types::SolEventInterface>::NAME,
3538 log: alloy_sol_types::private::Box::new(
3539 alloy_sol_types::private::LogData::new_unchecked(
3540 topics.to_vec(),
3541 data.to_vec().into(),
3542 ),
3543 ),
3544 })
3545 }
3546 }
3547 }
3548 }
3549 #[automatically_derived]
3550 impl alloy_sol_types::private::IntoLogData for IStrategyEvents {
3551 fn to_log_data(&self) -> alloy_sol_types::private::LogData {
3552 match self {
3553 Self::ExchangeRateEmitted(inner) => {
3554 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3555 }
3556 Self::StrategyTokenSet(inner) => {
3557 alloy_sol_types::private::IntoLogData::to_log_data(inner)
3558 }
3559 }
3560 }
3561 fn into_log_data(self) -> alloy_sol_types::private::LogData {
3562 match self {
3563 Self::ExchangeRateEmitted(inner) => {
3564 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3565 }
3566 Self::StrategyTokenSet(inner) => {
3567 alloy_sol_types::private::IntoLogData::into_log_data(inner)
3568 }
3569 }
3570 }
3571 }
3572 use alloy::contract as alloy_contract;
3573 #[inline]
3577 pub const fn new<
3578 T: alloy_contract::private::Transport + ::core::clone::Clone,
3579 P: alloy_contract::private::Provider<T, N>,
3580 N: alloy_contract::private::Network,
3581 >(
3582 address: alloy_sol_types::private::Address,
3583 provider: P,
3584 ) -> IStrategyInstance<T, P, N> {
3585 IStrategyInstance::<T, P, N>::new(address, provider)
3586 }
3587 #[inline]
3593 pub fn deploy<
3594 T: alloy_contract::private::Transport + ::core::clone::Clone,
3595 P: alloy_contract::private::Provider<T, N>,
3596 N: alloy_contract::private::Network,
3597 >(
3598 provider: P,
3599 ) -> impl ::core::future::Future<
3600 Output = alloy_contract::Result<IStrategyInstance<T, P, N>>,
3601 > {
3602 IStrategyInstance::<T, P, N>::deploy(provider)
3603 }
3604 #[inline]
3610 pub fn deploy_builder<
3611 T: alloy_contract::private::Transport + ::core::clone::Clone,
3612 P: alloy_contract::private::Provider<T, N>,
3613 N: alloy_contract::private::Network,
3614 >(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
3615 IStrategyInstance::<T, P, N>::deploy_builder(provider)
3616 }
3617 #[derive(Clone)]
3629 pub struct IStrategyInstance<T, P, N = alloy_contract::private::Ethereum> {
3630 address: alloy_sol_types::private::Address,
3631 provider: P,
3632 _network_transport: ::core::marker::PhantomData<(N, T)>,
3633 }
3634 #[automatically_derived]
3635 impl<T, P, N> ::core::fmt::Debug for IStrategyInstance<T, P, N> {
3636 #[inline]
3637 fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
3638 f.debug_tuple("IStrategyInstance").field(&self.address).finish()
3639 }
3640 }
3641 #[automatically_derived]
3643 impl<
3644 T: alloy_contract::private::Transport + ::core::clone::Clone,
3645 P: alloy_contract::private::Provider<T, N>,
3646 N: alloy_contract::private::Network,
3647 > IStrategyInstance<T, P, N> {
3648 #[inline]
3652 pub const fn new(
3653 address: alloy_sol_types::private::Address,
3654 provider: P,
3655 ) -> Self {
3656 Self {
3657 address,
3658 provider,
3659 _network_transport: ::core::marker::PhantomData,
3660 }
3661 }
3662 #[inline]
3668 pub async fn deploy(
3669 provider: P,
3670 ) -> alloy_contract::Result<IStrategyInstance<T, P, N>> {
3671 let call_builder = Self::deploy_builder(provider);
3672 let contract_address = call_builder.deploy().await?;
3673 Ok(Self::new(contract_address, call_builder.provider))
3674 }
3675 #[inline]
3681 pub fn deploy_builder(provider: P) -> alloy_contract::RawCallBuilder<T, P, N> {
3682 alloy_contract::RawCallBuilder::new_raw_deploy(
3683 provider,
3684 ::core::clone::Clone::clone(&BYTECODE),
3685 )
3686 }
3687 #[inline]
3689 pub const fn address(&self) -> &alloy_sol_types::private::Address {
3690 &self.address
3691 }
3692 #[inline]
3694 pub fn set_address(&mut self, address: alloy_sol_types::private::Address) {
3695 self.address = address;
3696 }
3697 pub fn at(mut self, address: alloy_sol_types::private::Address) -> Self {
3699 self.set_address(address);
3700 self
3701 }
3702 #[inline]
3704 pub const fn provider(&self) -> &P {
3705 &self.provider
3706 }
3707 }
3708 impl<T, P: ::core::clone::Clone, N> IStrategyInstance<T, &P, N> {
3709 #[inline]
3711 pub fn with_cloned_provider(self) -> IStrategyInstance<T, P, N> {
3712 IStrategyInstance {
3713 address: self.address,
3714 provider: ::core::clone::Clone::clone(&self.provider),
3715 _network_transport: ::core::marker::PhantomData,
3716 }
3717 }
3718 }
3719 #[automatically_derived]
3721 impl<
3722 T: alloy_contract::private::Transport + ::core::clone::Clone,
3723 P: alloy_contract::private::Provider<T, N>,
3724 N: alloy_contract::private::Network,
3725 > IStrategyInstance<T, P, N> {
3726 pub fn call_builder<C: alloy_sol_types::SolCall>(
3731 &self,
3732 call: &C,
3733 ) -> alloy_contract::SolCallBuilder<T, &P, C, N> {
3734 alloy_contract::SolCallBuilder::new_sol(&self.provider, &self.address, call)
3735 }
3736 pub fn deposit(
3738 &self,
3739 token: alloy::sol_types::private::Address,
3740 amount: alloy::sol_types::private::primitives::aliases::U256,
3741 ) -> alloy_contract::SolCallBuilder<T, &P, depositCall, N> {
3742 self.call_builder(&depositCall { token, amount })
3743 }
3744 pub fn explanation(
3746 &self,
3747 ) -> alloy_contract::SolCallBuilder<T, &P, explanationCall, N> {
3748 self.call_builder(&explanationCall {})
3749 }
3750 pub fn shares(
3752 &self,
3753 user: alloy::sol_types::private::Address,
3754 ) -> alloy_contract::SolCallBuilder<T, &P, sharesCall, N> {
3755 self.call_builder(&sharesCall { user })
3756 }
3757 pub fn sharesToUnderlying(
3759 &self,
3760 amountShares: alloy::sol_types::private::primitives::aliases::U256,
3761 ) -> alloy_contract::SolCallBuilder<T, &P, sharesToUnderlyingCall, N> {
3762 self.call_builder(
3763 &sharesToUnderlyingCall {
3764 amountShares,
3765 },
3766 )
3767 }
3768 pub fn sharesToUnderlyingView(
3770 &self,
3771 amountShares: alloy::sol_types::private::primitives::aliases::U256,
3772 ) -> alloy_contract::SolCallBuilder<T, &P, sharesToUnderlyingViewCall, N> {
3773 self.call_builder(
3774 &sharesToUnderlyingViewCall {
3775 amountShares,
3776 },
3777 )
3778 }
3779 pub fn totalShares(
3781 &self,
3782 ) -> alloy_contract::SolCallBuilder<T, &P, totalSharesCall, N> {
3783 self.call_builder(&totalSharesCall {})
3784 }
3785 pub fn underlyingToShares(
3787 &self,
3788 amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
3789 ) -> alloy_contract::SolCallBuilder<T, &P, underlyingToSharesCall, N> {
3790 self.call_builder(
3791 &underlyingToSharesCall {
3792 amountUnderlying,
3793 },
3794 )
3795 }
3796 pub fn underlyingToSharesView(
3798 &self,
3799 amountUnderlying: alloy::sol_types::private::primitives::aliases::U256,
3800 ) -> alloy_contract::SolCallBuilder<T, &P, underlyingToSharesViewCall, N> {
3801 self.call_builder(
3802 &underlyingToSharesViewCall {
3803 amountUnderlying,
3804 },
3805 )
3806 }
3807 pub fn underlyingToken(
3809 &self,
3810 ) -> alloy_contract::SolCallBuilder<T, &P, underlyingTokenCall, N> {
3811 self.call_builder(&underlyingTokenCall {})
3812 }
3813 pub fn userUnderlying(
3815 &self,
3816 user: alloy::sol_types::private::Address,
3817 ) -> alloy_contract::SolCallBuilder<T, &P, userUnderlyingCall, N> {
3818 self.call_builder(&userUnderlyingCall { user })
3819 }
3820 pub fn userUnderlyingView(
3822 &self,
3823 user: alloy::sol_types::private::Address,
3824 ) -> alloy_contract::SolCallBuilder<T, &P, userUnderlyingViewCall, N> {
3825 self.call_builder(&userUnderlyingViewCall { user })
3826 }
3827 pub fn version(&self) -> alloy_contract::SolCallBuilder<T, &P, versionCall, N> {
3829 self.call_builder(&versionCall {})
3830 }
3831 pub fn withdraw(
3833 &self,
3834 recipient: alloy::sol_types::private::Address,
3835 token: alloy::sol_types::private::Address,
3836 amountShares: alloy::sol_types::private::primitives::aliases::U256,
3837 ) -> alloy_contract::SolCallBuilder<T, &P, withdrawCall, N> {
3838 self.call_builder(
3839 &withdrawCall {
3840 recipient,
3841 token,
3842 amountShares,
3843 },
3844 )
3845 }
3846 }
3847 #[automatically_derived]
3849 impl<
3850 T: alloy_contract::private::Transport + ::core::clone::Clone,
3851 P: alloy_contract::private::Provider<T, N>,
3852 N: alloy_contract::private::Network,
3853 > IStrategyInstance<T, P, N> {
3854 pub fn event_filter<E: alloy_sol_types::SolEvent>(
3859 &self,
3860 ) -> alloy_contract::Event<T, &P, E, N> {
3861 alloy_contract::Event::new_sol(&self.provider, &self.address)
3862 }
3863 pub fn ExchangeRateEmitted_filter(
3865 &self,
3866 ) -> alloy_contract::Event<T, &P, ExchangeRateEmitted, N> {
3867 self.event_filter::<ExchangeRateEmitted>()
3868 }
3869 pub fn StrategyTokenSet_filter(
3871 &self,
3872 ) -> alloy_contract::Event<T, &P, StrategyTokenSet, N> {
3873 self.event_filter::<StrategyTokenSet>()
3874 }
3875 }
3876}