Struct ReactiveInputRecord 

pub struct ReactiveInputRecord<N: Network = Ethereum> {
    pub input: ReactiveInput<N>,
    pub context: ReactiveContext,
    pub provider: Option<ProviderRef>,
}

One input and its execution context.

Fields

input: ReactiveInput<N>

Input value.

context: ReactiveContext

Input context.

provider: Option<ProviderRef>

Provider session that originated this input, when it came from a concrete provider rather than a synthetic or aggregate source.

Implementations

impl<N: Network> ReactiveInputRecord<N>

pub fn new(input: ReactiveInput<N>, context: ReactiveContext) -> Self

Create an input record.

pub fn with_provider(self, provider: ProviderRef) -> Self

Attach provider provenance used to route follow-up reads.

pub fn input_ref(&self) -> InputRef

Compute the stable input reference used for deduplication.

pub fn validated_identity(&self) -> Result<ReactiveInputIdentity, ReactiveError>

Validate payload/context coherence and return a representation-aware identity suitable for subscriber and runtime deduplication.

Validation is fail-closed for canonical logs: their block, transaction, and log positions must be complete and agree with the context. Block and pending-transaction representations receive the corresponding lifecycle, inclusion-wrapper, and payload/context checks. This does not recompute a claimed header hash, transaction root, or transaction signature; exact subscriber payload commitments remain the transport-integrity boundary for those cryptographic claims.

Errors

Returns ReactiveError::InvalidInputRecord when the payload, lifecycle, inclusion metadata, or context is incomplete or internally inconsistent.

pub fn same_deduplicable_payload(&self, other: &Self) -> bool

Whether two same-identity records carry the same deduplicable payload.

This deliberately ignores ReactiveContext: the same provider object can legitimately arrive from backfill and subscription transports with different provenance or confirmation metadata. Callers must first compare validated_identity and reconcile lifecycle/context authority separately. Logs are compared structurally; block and transaction hashes are cryptographic commitments for the remaining same-representation payloads. Full block responses and hydrated pending transaction bodies deliberately return false: the core does not currently prove a supplied body against the header’s transaction root or compare every response field, so a composite source must preserve both rather than suppress one based only on its hash.

pub fn is_payload_deduplicable(&self) -> bool

Whether this representation has a complete payload-equivalence contract and may participate in duplicate suppression.

Full block and hydrated pending transaction bodies are intentionally excluded until their complete body/response integrity is validated.

pub fn merge_compatible_duplicate( &mut self, other: &Self, ) -> Result<bool, ReactiveError>

Merge other when it is the same safely deduplicable provider object.

Returns Ok(false) for a different identity or a representation whose complete payload cannot be proven equivalent. A same-identity payload or semantic conflict returns an error. Successful merges are deterministic: optional block/timestamp metadata is enriched, canonical lifecycle moves toward Finalized then Safe then the highest-confirmation Included, and provenance uses a stable source priority. The result is therefore independent of historical/live arrival order.

Errors

Returns ReactiveError when either record is invalid, or when equal identities carry conflicting payload or semantic context.

pub fn dedupe_context_is_compatible(&self, other: &Self) -> bool

Whether semantic context agrees for deduplication across transports.

Provenance source and confirmation count may legitimately differ at a historical/live overlap and are ignored. Chain id, lifecycle class, and transaction/log positions must agree. Block number/hash are exact; optional parent/timestamp metadata may be enriched by one source but two present conflicting values are rejected.

Trait Implementations

impl<N: Clone + Network> Clone for ReactiveInputRecord<N>

fn clone(&self) -> ReactiveInputRecord<N>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<N: Debug + Network> Debug for ReactiveInputRecord<N>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.