Trait Streamable 

pub trait Streamable {
    // Required methods
    fn update_digest(&self, digest: &mut Sha256);
    fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>;
    fn parse<const TRUSTED: bool>(
        input: &mut Cursor<&[u8]>,
    ) -> Result<Self, Error>
       where Self: Sized;

    // Provided methods
    fn to_bytes(&self) -> Result<Vec<u8>, Error> { ... }
    fn from_bytes(bytes: &[u8]) -> Result<Self, Error>
       where Self: Sized { ... }
    fn from_bytes_unchecked(bytes: &[u8]) -> Result<Self, Error>
       where Self: Sized { ... }
    fn hash(&self) -> [u8; 32] { ... }
}

Required Methods

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<Self, Error>

where Self: Sized,

Provided Methods

fn to_bytes(&self) -> Result<Vec<u8>, Error>

fn from_bytes(bytes: &[u8]) -> Result<Self, Error>

where Self: Sized,

fn from_bytes_unchecked(bytes: &[u8]) -> Result<Self, Error>

where Self: Sized,

fn hash(&self) -> [u8; 32]

Dyn Compatibility

This trait is dyn compatible.

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

Implementations on Foreign Types

impl Streamable for ()

fn update_digest(&self, _digest: &mut Sha256)

fn stream(&self, _out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(_input: &mut Cursor<&[u8]>) -> Result<(), Error>

impl Streamable for BlockRecord

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<BlockRecord, Error>

impl Streamable for Bytes

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<Bytes, Error>

impl Streamable for ChallengeBlockInfo

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<ChallengeBlockInfo, Error>

impl Streamable for ChallengeChainSubSlot

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<ChallengeChainSubSlot, Error>

impl Streamable for ClassgroupElement

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<ClassgroupElement, Error>

impl Streamable for Coin

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<Coin, Error>

impl Streamable for CoinSpend

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<CoinSpend, Error>

impl Streamable for CoinState

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<CoinState, Error>

impl Streamable for CoinStateFilters

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<CoinStateFilters, Error>

impl Streamable for CoinStateUpdate

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<CoinStateUpdate, Error>

impl Streamable for ConsensusConstants

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<ConsensusConstants, Error>

impl Streamable for EndOfSubSlotBundle

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<EndOfSubSlotBundle, Error>

impl Streamable for FeeEstimate

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<FeeEstimate, Error>

impl Streamable for FeeEstimateGroup

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<FeeEstimateGroup, Error>

impl Streamable for FeeRate

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<FeeRate, Error>

impl Streamable for Foliage

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<Foliage, Error>

impl Streamable for FoliageBlockData

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<FoliageBlockData, Error>

impl Streamable for FoliageTransactionBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<FoliageTransactionBlock, Error>

impl Streamable for FullBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<FullBlock, Error>

impl Streamable for GTElement

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<GTElement, Error>

impl Streamable for Handshake

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<Handshake, Error>

impl Streamable for HeaderBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<HeaderBlock, Error>

impl Streamable for InfusedChallengeChainSubSlot

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<InfusedChallengeChainSubSlot, Error>

impl Streamable for MempoolItemsAdded

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<MempoolItemsAdded, Error>

impl Streamable for MempoolItemsRemoved

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<MempoolItemsRemoved, Error>

impl Streamable for MempoolRemoveReason

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<MempoolRemoveReason, Error>

impl Streamable for Message

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<Message, Error>

impl Streamable for NewCompactVDF

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<NewCompactVDF, Error>

impl Streamable for NewPeak

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<NewPeak, Error>

impl Streamable for NewPeakWallet

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<NewPeakWallet, Error>

impl Streamable for NewSignagePointOrEndOfSubSlot

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<NewSignagePointOrEndOfSubSlot, Error>

impl Streamable for NewTransaction

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<NewTransaction, Error>

impl Streamable for NewUnfinishedBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<NewUnfinishedBlock, Error>

impl Streamable for NewUnfinishedBlock2

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<NewUnfinishedBlock2, Error>

impl Streamable for NodeType

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<NodeType, Error>

impl Streamable for OwnedSpendBundleConditions

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<OwnedSpendBundleConditions, Error>

impl Streamable for OwnedSpendConditions

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<OwnedSpendConditions, Error>

impl Streamable for PoolTarget

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<PoolTarget, Error>

impl Streamable for Program

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<Program, Error>

impl Streamable for ProofBlockHeader

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<ProofBlockHeader, Error>

impl Streamable for ProofOfSpace

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<ProofOfSpace, Error>

impl Streamable for PublicKey

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<PublicKey, Error>

impl Streamable for PuzzleSolutionResponse

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<PuzzleSolutionResponse, Error>

impl Streamable for RecentChainData

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RecentChainData, Error>

impl Streamable for RegisterForCoinUpdates

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RegisterForCoinUpdates, Error>

impl Streamable for RegisterForPhUpdates

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RegisterForPhUpdates, Error>

impl Streamable for RejectAdditionsRequest

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectAdditionsRequest, Error>

impl Streamable for RejectBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectBlock, Error>

impl Streamable for RejectBlockHeaders

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectBlockHeaders, Error>

impl Streamable for RejectBlocks

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectBlocks, Error>

impl Streamable for RejectCoinState

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectCoinState, Error>

impl Streamable for RejectHeaderBlocks

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectHeaderBlocks, Error>

impl Streamable for RejectHeaderRequest

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectHeaderRequest, Error>

impl Streamable for RejectPuzzleSolution

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectPuzzleSolution, Error>

impl Streamable for RejectPuzzleState

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectPuzzleState, Error>

impl Streamable for RejectRemovalsRequest

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectRemovalsRequest, Error>

impl Streamable for RejectStateReason

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RejectStateReason, Error>

impl Streamable for RemovedMempoolItem

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RemovedMempoolItem, Error>

impl Streamable for RequestAdditions

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestAdditions, Error>

impl Streamable for RequestBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestBlock, Error>

impl Streamable for RequestBlockHeader

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestBlockHeader, Error>

impl Streamable for RequestBlockHeaders

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestBlockHeaders, Error>

impl Streamable for RequestBlocks

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestBlocks, Error>

impl Streamable for RequestChildren

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestChildren, Error>

impl Streamable for RequestCoinState

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestCoinState, Error>

impl Streamable for RequestCompactVDF

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestCompactVDF, Error>

impl Streamable for RequestCostInfo

fn update_digest(&self, _digest: &mut Sha256)

fn stream(&self, _out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( _input: &mut Cursor<&[u8]>, ) -> Result<RequestCostInfo, Error>

impl Streamable for RequestFeeEstimates

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestFeeEstimates, Error>

impl Streamable for RequestHeaderBlocks

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestHeaderBlocks, Error>

impl Streamable for RequestMempoolTransactions

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestMempoolTransactions, Error>

impl Streamable for RequestPeers

fn update_digest(&self, _digest: &mut Sha256)

fn stream(&self, _out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( _input: &mut Cursor<&[u8]>, ) -> Result<RequestPeers, Error>

impl Streamable for RequestProofOfWeight

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestProofOfWeight, Error>

impl Streamable for RequestPuzzleSolution

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestPuzzleSolution, Error>

impl Streamable for RequestPuzzleState

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestPuzzleState, Error>

impl Streamable for RequestRemovals

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestRemovals, Error>

impl Streamable for RequestRemoveCoinSubscriptions

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestRemoveCoinSubscriptions, Error>

impl Streamable for RequestRemovePuzzleSubscriptions

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestRemovePuzzleSubscriptions, Error>

impl Streamable for RequestSesInfo

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestSesInfo, Error>

impl Streamable for RequestSignagePointOrEndOfSubSlot

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestSignagePointOrEndOfSubSlot, Error>

impl Streamable for RequestTransaction

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestTransaction, Error>

impl Streamable for RequestUnfinishedBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestUnfinishedBlock, Error>

impl Streamable for RequestUnfinishedBlock2

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RequestUnfinishedBlock2, Error>

impl Streamable for RespondAdditions

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondAdditions, Error>

impl Streamable for RespondBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondBlock, Error>

impl Streamable for RespondBlockHeader

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondBlockHeader, Error>

impl Streamable for RespondBlockHeaders

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondBlockHeaders, Error>

impl Streamable for RespondBlocks

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondBlocks, Error>

impl Streamable for RespondChildren

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondChildren, Error>

impl Streamable for RespondCoinState

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondCoinState, Error>

impl Streamable for RespondCompactVDF

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondCompactVDF, Error>

impl Streamable for RespondCostInfo

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondCostInfo, Error>

impl Streamable for RespondEndOfSubSlot

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondEndOfSubSlot, Error>

impl Streamable for RespondFeeEstimates

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondFeeEstimates, Error>

impl Streamable for RespondHeaderBlocks

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondHeaderBlocks, Error>

impl Streamable for RespondPeers

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondPeers, Error>

impl Streamable for RespondProofOfWeight

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondProofOfWeight, Error>

impl Streamable for RespondPuzzleSolution

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondPuzzleSolution, Error>

impl Streamable for RespondPuzzleState

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondPuzzleState, Error>

impl Streamable for RespondRemovals

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondRemovals, Error>

impl Streamable for RespondRemoveCoinSubscriptions

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondRemoveCoinSubscriptions, Error>

impl Streamable for RespondRemovePuzzleSubscriptions

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondRemovePuzzleSubscriptions, Error>

impl Streamable for RespondSesInfo

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondSesInfo, Error>

impl Streamable for RespondSignagePoint

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondSignagePoint, Error>

impl Streamable for RespondToCoinUpdates

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondToCoinUpdates, Error>

impl Streamable for RespondToPhUpdates

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondToPhUpdates, Error>

impl Streamable for RespondTransaction

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondTransaction, Error>

impl Streamable for RespondUnfinishedBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RespondUnfinishedBlock, Error>

impl Streamable for RewardChainBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RewardChainBlock, Error>

impl Streamable for RewardChainBlockUnfinished

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RewardChainBlockUnfinished, Error>

impl Streamable for RewardChainSubSlot

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<RewardChainSubSlot, Error>

impl Streamable for SecretKey

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<SecretKey, Error>

impl Streamable for SendTransaction

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<SendTransaction, Error>

impl Streamable for Signature

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<Signature, Error>

impl Streamable for SpendBundle

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<SpendBundle, Error>

impl Streamable for String

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<String, Error>

impl Streamable for SubEpochChallengeSegment

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<SubEpochChallengeSegment, Error>

impl Streamable for SubEpochData

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<SubEpochData, Error>

impl Streamable for SubEpochSegments

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<SubEpochSegments, Error>

impl Streamable for SubEpochSummary

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<SubEpochSummary, Error>

impl Streamable for SubSlotData

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<SubSlotData, Error>

impl Streamable for SubSlotProofs

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<SubSlotProofs, Error>

impl Streamable for TransactionAck

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<TransactionAck, Error>

impl Streamable for TransactionsInfo

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<TransactionsInfo, Error>

impl Streamable for UnfinishedBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<UnfinishedBlock, Error>

impl Streamable for UnfinishedHeaderBlock

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<UnfinishedHeaderBlock, Error>

impl Streamable for VDFInfo

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<VDFInfo, Error>

impl Streamable for VDFProof

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<VDFProof, Error>

impl Streamable for WeightProof

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<WeightProof, Error>

impl Streamable for bool

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<bool, Error>

impl Streamable for i8

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<i8, Error>

impl Streamable for i16

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<i16, Error>

impl Streamable for i32

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<i32, Error>

impl Streamable for i64

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<i64, Error>

impl Streamable for i128

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<i128, Error>

impl Streamable for u8

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<u8, Error>

impl Streamable for u16

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<u16, Error>

impl Streamable for u32

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<u32, Error>

impl Streamable for u64

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<u64, Error>

impl Streamable for u128

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>(input: &mut Cursor<&[u8]>) -> Result<u128, Error>

impl<T, U, V, W> Streamable for (T, U, V, W)

where T: Streamable, U: Streamable, V: Streamable, W: Streamable,

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<(T, U, V, W), Error>

impl<T, U, V> Streamable for (T, U, V)

where T: Streamable, U: Streamable, V: Streamable,

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<(T, U, V), Error>

impl<T, U> Streamable for (T, U)

where T: Streamable, U: Streamable,

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<(T, U), Error>

impl<T> Streamable for Option<T>

where T: Streamable,

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<Option<T>, Error>

impl<T> Streamable for Vec<T>

where T: Streamable,

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<Vec<T>, Error>

impl<const N: usize> Streamable for BytesImpl<N>

fn update_digest(&self, digest: &mut Sha256)

fn stream(&self, out: &mut Vec<u8>) -> Result<(), Error>

fn parse<const TRUSTED: bool>( input: &mut Cursor<&[u8]>, ) -> Result<BytesImpl<N>, Error>

Implementors

impl Streamable for dig_peer_protocol::Bytes

impl Streamable for dig_peer_protocol::NodeType

impl Streamable for ProtocolMessageTypes

impl Streamable for RegisterAck

impl Streamable for RegisterPeer

impl Streamable for RequestPeersIntroducer

impl Streamable for RespondPeersIntroducer

impl Streamable for TimestampedPeerInfo