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", so this trait is not object safe.

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<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<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 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 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 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 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 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 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 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, 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<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<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> 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 ()

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<(), 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, 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 NftMetadata

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<NftMetadata, 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 NameNftMetadata

where D: ClvmDecoder<Node = N>,

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

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

where D: ClvmDecoder<Node = N>,

fn from_clvm(decoder: &D, node: N) -> Result<XchandlesSlotValue, 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, 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> 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 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 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 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 Vec<T>

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

fn from_clvm(decoder: &D, node: N) -> Result<Vec<T>, 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, 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, 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<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<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 RewardDistributorType

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorType, 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 AggSigKind

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<AggSigKind, 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 CoinProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<CoinProof, 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 LineageProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<LineageProof, 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 GenesisByCoinIdTailArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<GenesisByCoinIdTailArgs, 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 NftIntermediateLauncherArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<NftIntermediateLauncherArgs, 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 SingletonStruct

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<SingletonStruct, 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 VerifiedData

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<VerifiedData, 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 CatalogRegistryState

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<CatalogRegistryState, 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 RewardDistributorConstants

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorConstants, 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 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 VerificationLauncherKVList

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<VerificationLauncherKVList, 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 XchandlesRegistryState

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesRegistryState, 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 Force1of2RestrictedVariableMemo

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<Force1of2RestrictedVariableMemo, 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 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 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 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 MeltSingleton

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<MeltSingleton, 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 TransferNft

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<TransferNft, 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 TradePrice

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<TradePrice, 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 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 NftPack

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<NftPack, 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 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 RewardDistributorInitiatePayoutActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorInitiatePayoutActionArgs, 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 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 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 IntermediaryCoinProof

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<IntermediaryCoinProof, 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 RewardDistributorStakeActionArgs

where D: ClvmDecoder<Node = Node>,

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

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

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorStakeActionSolution, 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 RewardDistributorUnstakeActionArgs

where D: ClvmDecoder<Node = Node>,

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

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

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorUnstakeActionSolution, 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 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 XchandlesOracleActionArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesOracleActionArgs, 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 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 XchandlesUpdateActionArgs

where D: ClvmDecoder<Node = Node>,

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

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

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesUpdateActionSolution, 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 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 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 P2DelegatedBySingletonLayerArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2DelegatedBySingletonLayerArgs, 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 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 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 PackedSingletonStruct

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PackedSingletonStruct, 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 SlotSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<SlotSolution, 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 RewardDistributorCommitmentSlotValue

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorCommitmentSlotValue, 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 RewardDistributorRewardSlotValue

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<RewardDistributorRewardSlotValue, 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 XchandlesDataValue

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<XchandlesDataValue, 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 CatalogVerificationInnerPuzzleMakerArgs

where D: ClvmDecoder<Node = Node>,

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

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

where D: ClvmDecoder<Node = Node>,

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

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

where D: ClvmDecoder<Node = Node>,

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

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

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<VerificationLayerSolution, 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 BlsMember

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<BlsMember, 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 BlsTaprootMemberSolution

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<BlsTaprootMemberSolution, 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 K1Member

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<K1Member, 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 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 PasskeyMember

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<PasskeyMember, 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 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 R1Member

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<R1Member, 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 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 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 OneOfNArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<OneOfNArgs, 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 Force1of2RestrictedVariable

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<Force1of2RestrictedVariable, 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 PreventConditionOpcode

where D: ClvmDecoder<Node = Node>,

fn from_clvm( decoder: &D, node: Node, ) -> Result<PreventConditionOpcode, 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 P2CurriedArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<P2CurriedArgs, 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 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 RevocationArgs

where D: ClvmDecoder<Node = Node>,

fn from_clvm(decoder: &D, node: Node) -> Result<RevocationArgs, 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, 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 VerificationAsserterArgs<P>

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

fn from_clvm( decoder: &D, node: Node, ) -> Result<VerificationAsserterArgs<P>, 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, 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 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 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 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<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 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 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 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 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<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 VerificationAsserterSolution<S>

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

fn from_clvm( decoder: &D, node: Node, ) -> Result<VerificationAsserterSolution<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 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 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 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 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 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 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 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 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 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 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 WrapperMemo<T>

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

fn from_clvm(decoder: &D, node: Node) -> Result<WrapperMemo<T>, 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 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 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 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 VerificationLayer2ndCurryArgs<T>

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

fn from_clvm( decoder: &D, node: Node, ) -> Result<VerificationLayer2ndCurryArgs<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 P2DelegatedConditionsSolution<T>

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

fn from_clvm( decoder: &D, node: Node, ) -> Result<P2DelegatedConditionsSolution<T>, 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 Puzzle

impl FromClvm<Allocator> for NodePtr

impl FromClvm<Allocator> for Program

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

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 Signature

where D: ClvmDecoder<Node = N>,

Available on crate feature chia-bls only.

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<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>,