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