Trait FromClvm 

pub trait FromClvm<D>: Sized
where
    D: ClvmDecoder,
{
    // Required method
    fn from_clvm(
        decoder: &D,
        node: <D as ClvmDecoder>::Node,
    ) -> Result<Self, FromClvmError>;
}

Required Methods

fn from_clvm( decoder: &D, node: <D as ClvmDecoder>::Node, ) -> Result<Self, FromClvmError>

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl FromClvm<Allocator> for HashedPtr

fn from_clvm( decoder: &Allocator, node: NodePtr, ) -> Result<HashedPtr, FromClvmError>

impl<CM, Node, D> FromClvm<D> for P2ParentArgs<CM>

where CM: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<P2ParentArgs<CM>, FromClvmError>

impl<CM, Node, D> FromClvm<D> for RewardDistributorCatLockingPuzzleArgs<CM>

where CM: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorCatLockingPuzzleArgs<CM>, FromClvmError>

impl<CM, Node, D> FromClvm<D> for RewardDistributorCatUnlockingPuzzleArgs<CM>

where CM: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorCatUnlockingPuzzleArgs<CM>, FromClvmError>

impl<CMP, CMS, EP, ES, S, Node, D> FromClvm<D> for XchandlesExpireActionSolution<CMP, CMS, EP, ES, S>

where CMP: FromClvm<D>, CMS: FromClvm<D>, EP: FromClvm<D>, ES: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesExpireActionSolution<CMP, CMS, EP, ES, S>, FromClvmError>

impl<CMP, CMS, PP, PS, S, Node, D> FromClvm<D> for XchandlesRefundActionSolution<CMP, CMS, PP, PS, S>

where CMP: FromClvm<D>, CMS: FromClvm<D>, PP: FromClvm<D>, PS: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesRefundActionSolution<CMP, CMS, PP, PS, S>, FromClvmError>

impl<CMS, Node, D> FromClvm<D> for RewardDistributorCatLockingPuzzleSolution<CMS>

where CMS: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorCatLockingPuzzleSolution<CMS>, FromClvmError>

impl<CMS, Node, D> FromClvm<D> for RewardDistributorCatUnlockingPuzzleSolution<CMS>

where CMS: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorCatUnlockingPuzzleSolution<CMS>, FromClvmError>

impl<D> FromClvm<D> for K1PublicKey

where D: ClvmDecoder,

Available on crate feature chia-secp only.

fn from_clvm( decoder: &D, node: <D as ClvmDecoder>::Node, ) -> Result<K1PublicKey, FromClvmError>

impl<D> FromClvm<D> for K1Signature

where D: ClvmDecoder,

Available on crate feature chia-secp only.

fn from_clvm( decoder: &D, node: <D as ClvmDecoder>::Node, ) -> Result<K1Signature, FromClvmError>

impl<D> FromClvm<D> for R1PublicKey

where D: ClvmDecoder,

Available on crate feature chia-secp only.

fn from_clvm( decoder: &D, node: <D as ClvmDecoder>::Node, ) -> Result<R1PublicKey, FromClvmError>

impl<D> FromClvm<D> for R1Signature

where D: ClvmDecoder,

Available on crate feature chia-secp only.

fn from_clvm( decoder: &D, node: <D as ClvmDecoder>::Node, ) -> Result<R1Signature, FromClvmError>

impl<F, S, Node, D> FromClvm<D> for ActionLayerArgs<F, S>

where F: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<ActionLayerArgs<F, S>, FromClvmError>

impl<I, M, Node, D> FromClvm<D> for DidArgs<I, M>

where I: FromClvm<D>, M: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<DidArgs<I, M>, FromClvmError>

impl<I, M, Node, D> FromClvm<D> for NftStateLayerArgs<I, M>

where I: FromClvm<D>, M: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NftStateLayerArgs<I, M>, FromClvmError>

impl<I, Node, D> FromClvm<D> for AugmentedConditionSolution<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AugmentedConditionSolution<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for CatArgs<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<CatArgs<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for CatSolution<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<CatSolution<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for DelegatedPuzzleFeederArgs<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DelegatedPuzzleFeederArgs<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for DidSolution<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<DidSolution<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for NftOwnershipLayerSolution<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NftOwnershipLayerSolution<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for NftStateLayerSolution<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NftStateLayerSolution<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for OptionContractArgs<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<OptionContractArgs<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for OptionContractSolution<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<OptionContractSolution<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for SingletonArgs<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<SingletonArgs<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for SingletonSolution<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<SingletonSolution<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for StateSchedulerLayerSolution<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<StateSchedulerLayerSolution<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for WriterLayerArgs<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<WriterLayerArgs<I>, FromClvmError>

impl<I, Node, D> FromClvm<D> for WriterLayerSolution<I>

where I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<WriterLayerSolution<I>, FromClvmError>

impl<I, P, Node, D> FromClvm<D> for NftOwnershipLayerArgs<I, P>

where I: FromClvm<D>, P: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NftOwnershipLayerArgs<I, P>, FromClvmError>

impl<LP, Node, D> FromClvm<D> for RewardDistributorStakeActionArgs<LP>

where LP: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorStakeActionArgs<LP>, FromClvmError>

impl<LPS, Node, D> FromClvm<D> for RewardDistributorStakeActionSolution<LPS>

where LPS: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorStakeActionSolution<LPS>, FromClvmError>

impl<M, C, Node, D> FromClvm<D> for NewMetadataOutput<M, C>

where M: FromClvm<D>, C: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NewMetadataOutput<M, C>, FromClvmError>

impl<M, I, Node, D> FromClvm<D> for StateSchedulerLayerArgs<M, I>

where M: FromClvm<D>, I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<StateSchedulerLayerArgs<M, I>, FromClvmError>

impl<M, Node, D> FromClvm<D> for NewMetadataInfo<M>

where M: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NewMetadataInfo<M>, FromClvmError>

impl<M, T, Node, D> FromClvm<D> for DlLauncherKvList<M, T>

where M: FromClvm<D>, T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DlLauncherKvList<M, T>, FromClvmError>

impl<MV, DV, I, Node, D> FromClvm<D> for RestrictionsArgs<MV, DV, I>

where MV: FromClvm<D>, DV: FromClvm<D>, I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RestrictionsArgs<MV, DV, I>, FromClvmError>

impl<MV, DV, I, Node, D> FromClvm<D> for RestrictionsSolution<MV, DV, I>

where MV: FromClvm<D>, DV: FromClvm<D>, I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RestrictionsSolution<MV, DV, I>, FromClvmError>

impl<N, D, A, B> FromClvm<D> for (A, B)

where D: ClvmDecoder<Node = N>, A: FromClvm<D>, B: FromClvm<D>,

fn from_clvm(decoder: &D, node: N) -> Result<(A, B), FromClvmError>

impl<N, D, T, const LEN: usize> FromClvm<D> for [T; LEN]

where D: ClvmDecoder<Node = N>, T: FromClvm<D>,

fn from_clvm(decoder: &D, node: N) -> Result<[T; LEN], FromClvmError>

impl<N, D, T> FromClvm<D> for Arc<T>

where D: ClvmDecoder<Node = N>, T: FromClvm<D>,

fn from_clvm(decoder: &D, node: N) -> Result<Arc<T>, FromClvmError>

impl<N, D, T> FromClvm<D> for Box<T>

where D: ClvmDecoder<Node = N>, T: FromClvm<D>,

fn from_clvm(decoder: &D, node: N) -> Result<Box<T>, FromClvmError>

impl<N, D, T> FromClvm<D> for Option<T>

where D: ClvmDecoder<Node = N>, T: FromClvm<D>,

fn from_clvm(decoder: &D, node: N) -> Result<Option<T>, FromClvmError>

impl<N, D, T> FromClvm<D> for Rc<T>

where D: ClvmDecoder<Node = N>, T: FromClvm<D>,

fn from_clvm(decoder: &D, node: N) -> Result<Rc<T>, FromClvmError>

impl<N, D, T> FromClvm<D> for Vec<T>

where D: ClvmDecoder<Node = N>, T: FromClvm<D>,

fn from_clvm(decoder: &D, node: N) -> Result<Vec<T>, FromClvmError>

impl<N, D, const LEN: usize> FromClvm<D> for BytesImpl<LEN>

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<BytesImpl<LEN>, FromClvmError>

impl<N, D> FromClvm<D> for ()

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<(), FromClvmError>

impl<N, D> FromClvm<D> for BigInt

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<BigInt, FromClvmError>

impl<N, D> FromClvm<D> for CatNftMetadata

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<CatNftMetadata, FromClvmError>

impl<N, D> FromClvm<D> for DatastoreMetadata

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<DatastoreMetadata, FromClvmError>

impl<N, D> FromClvm<D> for HandleNftMetadata

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<HandleNftMetadata, FromClvmError>

impl<N, D> FromClvm<D> for NftMetadata

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<NftMetadata, FromClvmError>

impl<N, D> FromClvm<D> for NftPack

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<NftPack, FromClvmError>

impl<N, D> FromClvm<D> for RewardDistributorType

where D: ClvmDecoder<Node = N>,

fn from_clvm( decoder: &D, node: N, ) -> Result<RewardDistributorType, FromClvmError>

impl<N, D> FromClvm<D> for String

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<String, FromClvmError>

impl<N, D> FromClvm<D> for XchandlesHandleSlotValue

where D: ClvmDecoder<Node = N>,

fn from_clvm( decoder: &D, node: N, ) -> Result<XchandlesHandleSlotValue, FromClvmError>

impl<N, D> FromClvm<D> for XchandlesUpdateSlotValue

where D: ClvmDecoder<Node = N>,

fn from_clvm( decoder: &D, node: N, ) -> Result<XchandlesUpdateSlotValue, FromClvmError>

impl<N, D> FromClvm<D> for bool

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<bool, FromClvmError>

impl<N, D> FromClvm<D> for i8

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<i8, FromClvmError>

impl<N, D> FromClvm<D> for i16

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<i16, FromClvmError>

impl<N, D> FromClvm<D> for i32

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<i32, FromClvmError>

impl<N, D> FromClvm<D> for i64

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<i64, FromClvmError>

impl<N, D> FromClvm<D> for i128

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<i128, FromClvmError>

impl<N, D> FromClvm<D> for isize

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<isize, FromClvmError>

impl<N, D> FromClvm<D> for u8

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<u8, FromClvmError>

impl<N, D> FromClvm<D> for u16

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<u16, FromClvmError>

impl<N, D> FromClvm<D> for u32

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<u32, FromClvmError>

impl<N, D> FromClvm<D> for u64

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<u64, FromClvmError>

impl<N, D> FromClvm<D> for u128

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<u128, FromClvmError>

impl<N, D> FromClvm<D> for usize

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<usize, FromClvmError>

impl<N, I, Node, D> FromClvm<D> for IndexWrapperArgs<N, I>

where N: FromClvm<D>, I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<IndexWrapperArgs<N, I>, FromClvmError>

impl<N, I, Node, D> FromClvm<D> for NonceWrapperArgs<N, I>

where N: FromClvm<D>, I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NonceWrapperArgs<N, I>, FromClvmError>

impl<Node, D> FromClvm<D> for AggSig

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AggSig, FromClvmError>

impl<Node, D> FromClvm<D> for AggSigAmount

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AggSigAmount, FromClvmError>

impl<Node, D> FromClvm<D> for AggSigKind

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AggSigKind, FromClvmError>

impl<Node, D> FromClvm<D> for AggSigMe

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AggSigMe, FromClvmError>

impl<Node, D> FromClvm<D> for AggSigParent

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AggSigParent, FromClvmError>

impl<Node, D> FromClvm<D> for AggSigParentAmount

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AggSigParentAmount, FromClvmError>

impl<Node, D> FromClvm<D> for AggSigParentPuzzle

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AggSigParentPuzzle, FromClvmError>

impl<Node, D> FromClvm<D> for AggSigPuzzle

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AggSigPuzzle, FromClvmError>

impl<Node, D> FromClvm<D> for AggSigPuzzleAmount

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AggSigPuzzleAmount, FromClvmError>

impl<Node, D> FromClvm<D> for AggSigUnsafe

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AggSigUnsafe, FromClvmError>

impl<Node, D> FromClvm<D> for AssertBeforeHeightAbsolute

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertBeforeHeightAbsolute, FromClvmError>

impl<Node, D> FromClvm<D> for AssertBeforeHeightRelative

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertBeforeHeightRelative, FromClvmError>

impl<Node, D> FromClvm<D> for AssertBeforeSecondsAbsolute

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertBeforeSecondsAbsolute, FromClvmError>

impl<Node, D> FromClvm<D> for AssertBeforeSecondsRelative

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertBeforeSecondsRelative, FromClvmError>

impl<Node, D> FromClvm<D> for AssertCoinAnnouncement

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertCoinAnnouncement, FromClvmError>

impl<Node, D> FromClvm<D> for AssertConcurrentPuzzle

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertConcurrentPuzzle, FromClvmError>

impl<Node, D> FromClvm<D> for AssertConcurrentSpend

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertConcurrentSpend, FromClvmError>

impl<Node, D> FromClvm<D> for AssertEphemeral

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AssertEphemeral, FromClvmError>

impl<Node, D> FromClvm<D> for AssertHeightAbsolute

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertHeightAbsolute, FromClvmError>

impl<Node, D> FromClvm<D> for AssertHeightRelative

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertHeightRelative, FromClvmError>

impl<Node, D> FromClvm<D> for AssertMyAmount

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AssertMyAmount, FromClvmError>

impl<Node, D> FromClvm<D> for AssertMyBirthHeight

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertMyBirthHeight, FromClvmError>

impl<Node, D> FromClvm<D> for AssertMyBirthSeconds

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertMyBirthSeconds, FromClvmError>

impl<Node, D> FromClvm<D> for AssertMyCoinId

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AssertMyCoinId, FromClvmError>

impl<Node, D> FromClvm<D> for AssertMyParentId

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AssertMyParentId, FromClvmError>

impl<Node, D> FromClvm<D> for AssertMyPuzzleHash

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertMyPuzzleHash, FromClvmError>

impl<Node, D> FromClvm<D> for AssertPuzzleAnnouncement

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertPuzzleAnnouncement, FromClvmError>

impl<Node, D> FromClvm<D> for AssertSecondsAbsolute

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertSecondsAbsolute, FromClvmError>

impl<Node, D> FromClvm<D> for AssertSecondsRelative

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AssertSecondsRelative, FromClvmError>

impl<Node, D> FromClvm<D> for BlsMember

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<BlsMember, FromClvmError>

impl<Node, D> FromClvm<D> for BlsMemberPuzzleAssert

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<BlsMemberPuzzleAssert, FromClvmError>

impl<Node, D> FromClvm<D> for BlsTaprootMember

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<BlsTaprootMember, FromClvmError>

impl<Node, D> FromClvm<D> for BlsTaprootMemberPuzzleAssert

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<BlsTaprootMemberPuzzleAssert, FromClvmError>

impl<Node, D> FromClvm<D> for BlsTaprootMemberPuzzleAssertSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<BlsTaprootMemberPuzzleAssertSolution, FromClvmError>

impl<Node, D> FromClvm<D> for BlsTaprootMemberSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<BlsTaprootMemberSolution, FromClvmError>

impl<Node, D> FromClvm<D> for BulletinMessage

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<BulletinMessage, FromClvmError>

impl<Node, D> FromClvm<D> for CatalogDoubleTailHashData

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CatalogDoubleTailHashData, FromClvmError>

impl<Node, D> FromClvm<D> for CatalogOtherPrecommitData

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CatalogOtherPrecommitData, FromClvmError>

impl<Node, D> FromClvm<D> for CatalogRefundActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CatalogRefundActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for CatalogRegisterActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CatalogRegisterActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for CatalogRegistryState

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CatalogRegistryState, FromClvmError>

impl<Node, D> FromClvm<D> for CatalogSlotValue

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<CatalogSlotValue, FromClvmError>

impl<Node, D> FromClvm<D> for CoinProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<CoinProof, FromClvmError>

impl<Node, D> FromClvm<D> for CompactCoinProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<CompactCoinProof, FromClvmError>

impl<Node, D> FromClvm<D> for CompactLineageProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CompactLineageProof, FromClvmError>

impl<Node, D> FromClvm<D> for CreateCoinAnnouncement

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CreateCoinAnnouncement, FromClvmError>

impl<Node, D> FromClvm<D> for CreatePuzzleAnnouncement

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CreatePuzzleAnnouncement, FromClvmError>

impl<Node, D> FromClvm<D> for DefaultCatMakerArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DefaultCatMakerArgs, FromClvmError>

impl<Node, D> FromClvm<D> for DefaultFinalizer1stCurryArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DefaultFinalizer1stCurryArgs, FromClvmError>

impl<Node, D> FromClvm<D> for DefaultFinalizer2ndCurryArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DefaultFinalizer2ndCurryArgs, FromClvmError>

impl<Node, D> FromClvm<D> for DelegatedStateActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DelegatedStateActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for DelegationLayerArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DelegationLayerArgs, FromClvmError>

impl<Node, D> FromClvm<D> for DidRecoverySolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DidRecoverySolution, FromClvmError>

impl<Node, D> FromClvm<D> for EnforceDelegatedPuzzleWrappers

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<EnforceDelegatedPuzzleWrappers, FromClvmError>

impl<Node, D> FromClvm<D> for EnforceDelegatedPuzzleWrappersSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<EnforceDelegatedPuzzleWrappersSolution, FromClvmError>

impl<Node, D> FromClvm<D> for EveProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<EveProof, FromClvmError>

impl<Node, D> FromClvm<D> for EverythingWithSignatureTailArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<EverythingWithSignatureTailArgs, FromClvmError>

impl<Node, D> FromClvm<D> for EverythingWithSingletonTailArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<EverythingWithSingletonTailArgs, FromClvmError>

impl<Node, D> FromClvm<D> for EverythingWithSingletonTailSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<EverythingWithSingletonTailSolution, FromClvmError>

impl<Node, D> FromClvm<D> for FixedPuzzleMember

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<FixedPuzzleMember, FromClvmError>

impl<Node, D> FromClvm<D> for Force1of2RestrictedVariable

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<Force1of2RestrictedVariable, FromClvmError>

impl<Node, D> FromClvm<D> for Force1of2RestrictedVariableMemo

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<Force1of2RestrictedVariableMemo, FromClvmError>

impl<Node, D> FromClvm<D> for Force1of2RestrictedVariableSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<Force1of2RestrictedVariableSolution, FromClvmError>

impl<Node, D> FromClvm<D> for GenesisByCoinIdTailArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<GenesisByCoinIdTailArgs, FromClvmError>

impl<Node, D> FromClvm<D> for HintType

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<HintType, FromClvmError>

impl<Node, D> FromClvm<D> for IntermediaryCoinProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<IntermediaryCoinProof, FromClvmError>

impl<Node, D> FromClvm<D> for K1Member

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<K1Member, FromClvmError>

impl<Node, D> FromClvm<D> for K1MemberPuzzleAssert

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<K1MemberPuzzleAssert, FromClvmError>

impl<Node, D> FromClvm<D> for K1MemberPuzzleAssertSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<K1MemberPuzzleAssertSolution, FromClvmError>

impl<Node, D> FromClvm<D> for K1MemberSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<K1MemberSolution, FromClvmError>

impl<Node, D> FromClvm<D> for LineageProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<LineageProof, FromClvmError>

impl<Node, D> FromClvm<D> for MedievalVaultHint

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<MedievalVaultHint, FromClvmError>

impl<Node, D> FromClvm<D> for MeltSingleton

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<MeltSingleton, FromClvmError>

impl<Node, D> FromClvm<D> for MerkleProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<MerkleProof, FromClvmError>

impl<Node, D> FromClvm<D> for MofNArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<MofNArgs, FromClvmError>

impl<Node, D> FromClvm<D> for NftIntermediateLauncherArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NftIntermediateLauncherArgs, FromClvmError>

impl<Node, D> FromClvm<D> for NftLauncherProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<NftLauncherProof, FromClvmError>

impl<Node, D> FromClvm<D> for NftRoyaltyTransferPuzzleArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NftRoyaltyTransferPuzzleArgs, FromClvmError>

impl<Node, D> FromClvm<D> for NftToUnlockInfo

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<NftToUnlockInfo, FromClvmError>

impl<Node, D> FromClvm<D> for OneOfNArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<OneOfNArgs, FromClvmError>

impl<Node, D> FromClvm<D> for OptionMetadata

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<OptionMetadata, FromClvmError>

impl<Node, D> FromClvm<D> for OptionType

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<OptionType, FromClvmError>

impl<Node, D> FromClvm<D> for P2CurriedArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<P2CurriedArgs, FromClvmError>

impl<Node, D> FromClvm<D> for P2DelegatedBySingletonLayerArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2DelegatedBySingletonLayerArgs, FromClvmError>

impl<Node, D> FromClvm<D> for P2DelegatedConditionsArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2DelegatedConditionsArgs, FromClvmError>

impl<Node, D> FromClvm<D> for P2MOfNDelegateDirectArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2MOfNDelegateDirectArgs, FromClvmError>

impl<Node, D> FromClvm<D> for P2NextRewardDistributorEpochArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2NextRewardDistributorEpochArgs, FromClvmError>

impl<Node, D> FromClvm<D> for P2NextRewardDistributorEpochSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2NextRewardDistributorEpochSolution, FromClvmError>

impl<Node, D> FromClvm<D> for P2OneOfManyArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<P2OneOfManyArgs, FromClvmError>

impl<Node, D> FromClvm<D> for P2SingletonArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<P2SingletonArgs, FromClvmError>

impl<Node, D> FromClvm<D> for P2SingletonSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2SingletonSolution, FromClvmError>

impl<Node, D> FromClvm<D> for PackedSingletonStruct

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PackedSingletonStruct, FromClvmError>

impl<Node, D> FromClvm<D> for PasskeyMember

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<PasskeyMember, FromClvmError>

impl<Node, D> FromClvm<D> for PasskeyMemberPuzzleAssert

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PasskeyMemberPuzzleAssert, FromClvmError>

impl<Node, D> FromClvm<D> for PasskeyMemberPuzzleAssertSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PasskeyMemberPuzzleAssertSolution, FromClvmError>

impl<Node, D> FromClvm<D> for PasskeyMemberSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PasskeyMemberSolution, FromClvmError>

impl<Node, D> FromClvm<D> for PrecommitLayer1stCurryArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PrecommitLayer1stCurryArgs, FromClvmError>

impl<Node, D> FromClvm<D> for PrecommitLayerSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PrecommitLayerSolution, FromClvmError>

impl<Node, D> FromClvm<D> for PrecommitSpendMode

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PrecommitSpendMode, FromClvmError>

impl<Node, D> FromClvm<D> for PreventConditionOpcode

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PreventConditionOpcode, FromClvmError>

impl<Node, D> FromClvm<D> for Proof

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<Proof, FromClvmError>

impl<Node, D> FromClvm<D> for R1Member

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<R1Member, FromClvmError>

impl<Node, D> FromClvm<D> for R1MemberPuzzleAssert

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<R1MemberPuzzleAssert, FromClvmError>

impl<Node, D> FromClvm<D> for R1MemberPuzzleAssertSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<R1MemberPuzzleAssertSolution, FromClvmError>

impl<Node, D> FromClvm<D> for R1MemberSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<R1MemberSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RefreshNftInfo

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<RefreshNftInfo, FromClvmError>

impl<Node, D> FromClvm<D> for ReserveFee

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<ReserveFee, FromClvmError>

impl<Node, D> FromClvm<D> for ReserveFinalizer2ndCurryArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<ReserveFinalizer2ndCurryArgs, FromClvmError>

impl<Node, D> FromClvm<D> for ReserveFinalizerSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<ReserveFinalizerSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RevocableCatMakerArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RevocableCatMakerArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RevocableCatMakerStruct

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RevocableCatMakerStruct, FromClvmError>

impl<Node, D> FromClvm<D> for RevocationArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<RevocationArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorAddEntryActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorAddEntryActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorAddEntryActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorAddEntryActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorAddIncentivesActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorAddIncentivesActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorAddIncentivesActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorAddIncentivesActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorCommitIncentivesActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorCommitIncentivesActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorCommitIncentivesActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorCommitIncentivesActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorCommitmentSlotValue

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorCommitmentSlotValue, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorConstants

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorConstants, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorDlInfo

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorDlInfo, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorEntryPayoutInfo

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorEntryPayoutInfo, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorEntrySlotValue

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorEntrySlotValue, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorInitiatePayoutActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorInitiatePayoutActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorInitiatePayoutWithApprovalActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorInitiatePayoutWithApprovalActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorInitiatePayoutWithoutApprovalActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorInitiatePayoutWithoutApprovalActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorNewEpochActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorNewEpochActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorNewEpochActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorNewEpochActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorNftsFromDidLockingPuzzleArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorNftsFromDidLockingPuzzleArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorNftsFromDidLockingPuzzleSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorNftsFromDidLockingPuzzleSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorNftsFromDlLockingPuzzleArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorNftsFromDlLockingPuzzleArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorNftsFromDlLockingPuzzleSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorNftsFromDlLockingPuzzleSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorNftsUnlockingPuzzleArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorNftsUnlockingPuzzleArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorRefreshNftsFromDlActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorRefreshNftsFromDlActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorRefreshNftsFromDlActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorRefreshNftsFromDlActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorRefreshNftsTotals

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorRefreshNftsTotals, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorRemoveEntryActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorRemoveEntryActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorRemoveEntryActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorRemoveEntryActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorRewardSlotValue

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorRewardSlotValue, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorState

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorState, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorSyncActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorSyncActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorWithdrawIncentivesActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorWithdrawIncentivesActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for RewardDistributorWithdrawIncentivesActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorWithdrawIncentivesActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for RoundRewardInfo

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<RoundRewardInfo, FromClvmError>

impl<Node, D> FromClvm<D> for RoundTimeInfo

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<RoundTimeInfo, FromClvmError>

impl<Node, D> FromClvm<D> for SingletonMember

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<SingletonMember, FromClvmError>

impl<Node, D> FromClvm<D> for SingletonMemberSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<SingletonMemberSolution, FromClvmError>

impl<Node, D> FromClvm<D> for SingletonMemberWithMode

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<SingletonMemberWithMode, FromClvmError>

impl<Node, D> FromClvm<D> for SingletonMemberWithModeSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<SingletonMemberWithModeSolution, FromClvmError>

impl<Node, D> FromClvm<D> for SingletonStruct

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<SingletonStruct, FromClvmError>

impl<Node, D> FromClvm<D> for Slot1stCurryArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<Slot1stCurryArgs, FromClvmError>

impl<Node, D> FromClvm<D> for Slot2ndCurryArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<Slot2ndCurryArgs, FromClvmError>

impl<Node, D> FromClvm<D> for SlotAndNfts

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<SlotAndNfts, FromClvmError>

impl<Node, D> FromClvm<D> for SlotNeigborsInfo

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<SlotNeigborsInfo, FromClvmError>

impl<Node, D> FromClvm<D> for SlotSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<SlotSolution, FromClvmError>

impl<Node, D> FromClvm<D> for StakeNftFromDidInfo

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<StakeNftFromDidInfo, FromClvmError>

impl<Node, D> FromClvm<D> for StakeNftFromDlInfo

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<StakeNftFromDlInfo, FromClvmError>

impl<Node, D> FromClvm<D> for StandardArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<StandardArgs, FromClvmError>

impl<Node, D> FromClvm<D> for StreamPuzzle1stCurryArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<StreamPuzzle1stCurryArgs, FromClvmError>

impl<Node, D> FromClvm<D> for StreamPuzzle2ndCurryArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<StreamPuzzle2ndCurryArgs, FromClvmError>

impl<Node, D> FromClvm<D> for StreamPuzzleSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<StreamPuzzleSolution, FromClvmError>

impl<Node, D> FromClvm<D> for Timelock

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<Timelock, FromClvmError>

impl<Node, D> FromClvm<D> for TradePrice

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<TradePrice, FromClvmError>

impl<Node, D> FromClvm<D> for TransferNft

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<TransferNft, FromClvmError>

impl<Node, D> FromClvm<D> for UniquenessPrelauncher1stCurryArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<UniquenessPrelauncher1stCurryArgs, FromClvmError>

impl<Node, D> FromClvm<D> for UpdateDatastoreMerkleRoot

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<UpdateDatastoreMerkleRoot, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesConstants

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesConstants, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesDataValue

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesDataValue, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesExecuteUpdateActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesExecuteUpdateActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesExecuteUpdateActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesExecuteUpdateActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesExpireActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesExpireActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesExtendActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesExtendActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesFactorPricingPuzzleArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesFactorPricingPuzzleArgs, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesInitiateUpdateActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesInitiateUpdateActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesInitiateUpdateActionSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesInitiateUpdateActionSolution, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesNewDataPuzzleHashes

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesNewDataPuzzleHashes, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesOracleActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesOracleActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesPricingSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesPricingSolution, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesRefundActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesRefundActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesRegisterActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesRegisterActionArgs, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesRegistryState

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesRegistryState, FromClvmError>

impl<Node, D> FromClvm<D> for XchandlesRestOfSlot

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesRestOfSlot, FromClvmError>

impl<P, Node, D> FromClvm<D> for MofNSolution<P>

where P: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<MofNSolution<P>, FromClvmError>

impl<P, Node, D> FromClvm<D> for ReserveFinalizer1stCurryArgs<P>

where P: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<ReserveFinalizer1stCurryArgs<P>, FromClvmError>

impl<P, Node, D> FromClvm<D> for XchandlesExponentialPremiumRenewPuzzleArgs<P>

where P: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesExponentialPremiumRenewPuzzleArgs<P>, FromClvmError>

impl<P, S, F, Node, D> FromClvm<D> for RawActionLayerSolution<P, S, F>

where P: FromClvm<D>, S: FromClvm<D>, F: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RawActionLayerSolution<P, S, F>, FromClvmError>

impl<P, S, I, Node, D> FromClvm<D> for DelegatedPuzzleFeederSolution<P, S, I>

where P: FromClvm<D>, S: FromClvm<D>, I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DelegatedPuzzleFeederSolution<P, S, I>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for CatalogRefundActionSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CatalogRefundActionSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for CatalogRegisterActionSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CatalogRegisterActionSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for DelegationLayerSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DelegationLayerSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for OneOfNSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<OneOfNSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for P2CurriedSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2CurriedSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for P2DelegatedBySingletonLayerSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2DelegatedBySingletonLayerSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for P2MOfNDelegateDirectSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2MOfNDelegateDirectSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for P2OneOfManySolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2OneOfManySolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for PuzzleAndSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PuzzleAndSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for PuzzleHashPuzzleAndSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PuzzleHashPuzzleAndSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for RevocationSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RevocationSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for RunCatTail<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<RunCatTail<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for StandardSolution<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<StandardSolution<P, S>, FromClvmError>

impl<P, S, Node, D> FromClvm<D> for UpdateNftMetadata<P, S>

where P: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<UpdateNftMetadata<P, S>, FromClvmError>

impl<PIP, PS, CMS, Node, D> FromClvm<D> for P2ParentSolution<PIP, PS, CMS>

where PIP: FromClvm<D>, PS: FromClvm<D>, CMS: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2ParentSolution<PIP, PS, CMS>, FromClvmError>

impl<PP, PS, CMP, CMS, Node, D> FromClvm<D> for XchandlesExtendActionSolution<PP, PS, CMP, CMS>

where PP: FromClvm<D>, PS: FromClvm<D>, CMP: FromClvm<D>, CMS: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesExtendActionSolution<PP, PS, CMP, CMS>, FromClvmError>

impl<PP, PS, CMP, CMS, S, Node, D> FromClvm<D> for XchandlesRegisterActionSolution<PP, PS, CMP, CMS, S>

where PP: FromClvm<D>, PS: FromClvm<D>, CMP: FromClvm<D>, CMS: FromClvm<D>, S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesRegisterActionSolution<PP, PS, CMP, CMS, S>, FromClvmError>

impl<S, H, Node, D> FromClvm<D> for StateSchedulerLauncherHints<S, H>

where S: FromClvm<D>, H: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<StateSchedulerLauncherHints<S, H>, FromClvmError>

impl<S, Node, D> FromClvm<D> for DelegatedStateActionSolution<S>

where S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<DelegatedStateActionSolution<S>, FromClvmError>

impl<S, Node, D> FromClvm<D> for XchandlesOtherPrecommitData<S>

where S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesOtherPrecommitData<S>, FromClvmError>

impl<S, Node, D> FromClvm<D> for XchandlesRefundAndSecret<S>

where S: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesRefundAndSecret<S>, FromClvmError>

impl<T, I, Node, D> FromClvm<D> for AugmentedConditionArgs<T, I>

where T: FromClvm<D>, I: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AugmentedConditionArgs<T, I>, FromClvmError>

impl<T, Node, D> FromClvm<D> for CreateCoin<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<CreateCoin<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for InnerPuzzleMemo<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<InnerPuzzleMemo<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for LauncherSolution<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<LauncherSolution<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for MemberMemo<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<MemberMemo<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for MemoKind<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<MemoKind<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for Memos<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<Memos<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for MipsMemo<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<MipsMemo<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for MofNMemo<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<MofNMemo<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for NofNArgs<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<NofNArgs<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for NofNSolution<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<NofNSolution<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for NotarizedPayment<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NotarizedPayment<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for OldDlLauncherKvList<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<OldDlLauncherKvList<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for P2DelegatedConditionsSolution<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2DelegatedConditionsSolution<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for Payment<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<Payment<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for ReceiveMessage<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<ReceiveMessage<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for Remark<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<Remark<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for RestrictionMemo<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RestrictionMemo<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for SendMessage<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<SendMessage<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for SettlementPaymentsSolution<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<SettlementPaymentsSolution<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for Softfork<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<Softfork<T>, FromClvmError>

impl<T, Node, D> FromClvm<D> for WrapperMemo<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<WrapperMemo<T>, FromClvmError>

impl<UP, Node, D> FromClvm<D> for RewardDistributorUnstakeActionArgs<UP>

where UP: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorUnstakeActionArgs<UP>, FromClvmError>

impl<UPS, Node, D> FromClvm<D> for RewardDistributorUnstakeActionSolution<UPS>

where UPS: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorUnstakeActionSolution<UPS>, FromClvmError>

impl<V, Node, D> FromClvm<D> for PrecommitLayer2ndCurryArgs<V>

where V: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PrecommitLayer2ndCurryArgs<V>, FromClvmError>

impl<V, Node, D> FromClvm<D> for UniquenessPrelauncher2ndCurryArgs<V>

where V: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<UniquenessPrelauncher2ndCurryArgs<V>, FromClvmError>

impl<W, P, Node, D> FromClvm<D> for AddDelegatedPuzzleWrapper<W, P>

where W: FromClvm<D>, P: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AddDelegatedPuzzleWrapper<W, P>, FromClvmError>

impl<W, P, Node, D> FromClvm<D> for AddDelegatedPuzzleWrapperSolution<W, P>

where W: FromClvm<D>, P: FromClvm<D>, D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<AddDelegatedPuzzleWrapperSolution<W, P>, FromClvmError>

Implementors

impl FromClvm<Allocator> for NodePtr

impl FromClvm<Allocator> for Program

impl FromClvm<Allocator> for Puzzle

impl<N, D, P, A> FromClvm<D> for CurriedProgram<P, A>

where D: ClvmDecoder<Node = N>, P: FromClvm<D>, A: FromClvm<D>,

impl<N, D, const BYTE: u8> FromClvm<D> for MatchByte<BYTE>

where D: ClvmDecoder<Node = N>,

impl<N, D> FromClvm<D> for Bytes

where D: ClvmDecoder<Node = N>,

impl<N, D> FromClvm<D> for Coin

where D: ClvmDecoder<Node = N>,

impl<N, D> FromClvm<D> for PublicKey

where D: ClvmDecoder<Node = N>,

Available on crate feature chia-bls only.

impl<N, D> FromClvm<D> for Raw<N>

where D: ClvmDecoder<Node = N>,

impl<N, D> FromClvm<D> for Signature

where D: ClvmDecoder<Node = N>,

Available on crate feature chia-bls only.

impl<T, Node, D> FromClvm<D> for Condition<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,

impl<T, Node, D> FromClvm<D> for Conditions<T>

where T: FromClvm<D>, D: ClvmDecoder<Node = Node>,