Struct Keccak256Hasher 

pub struct Keccak256Hasher { /* private fields */ }

The admissible σ-axes (re-exports of prism’s hashers). Every realization binds Sha256Hasher by default and admits the others via its address_<algorithm> entry points. Sha512Hasher is a Hasher<64> (bound with AddrBounds64); the rest are Hasher<32>. Keccak-256 hasher. 32-byte digest. The pre-FIPS-202 sponge (the variant adopted by Ethereum); distinguished from SHA3-256 by the 0x01 vs 0x06 domain-separation byte.

Trait Implementations

impl AddrHash for Keccak256Hasher

const LABEL_PREFIX: &'static str = "keccak256"

The lowercase algorithm token at the head of the κ-label.

const OUTPUT_BYTES: usize = 32

The σ-axis digest width in bytes (Hasher::OUTPUT_BYTES).

fn digest_carrier<const N: usize>(input: &TermValue<'_, N>) -> [u8; 64]

Fold the (streamed) canonical carrier through this σ-axis, returning the digest in a MAX_DIGEST_BYTES buffer (first OUTPUT_BYTES significant; the rest zero). Bounded resident memory — never materializes the carrier.

const LABEL_BYTES: usize = _

Total κ-label ASCII width = LABEL_PREFIX.len() + 1 + 2 × OUTPUT_BYTES. The realization’s output shape declares exactly this many Site constraints, and the entry point returns KappaLabel<{LABEL_BYTES}>.

impl<const INLINE_BYTES: usize, const FP_MAX: usize> AxisExtension<INLINE_BYTES, FP_MAX> for Keccak256Hasher

const AXIS_ADDRESS: &'static str = <Keccak256Hasher as HashAxis>::AXIS_ADDRESS

ADR-017 content address of this axis trait. The SDK macro derives this from the trait name and method signatures.

const MAX_OUTPUT_BYTES: usize = <Keccak256Hasher as HashAxis>::MAX_OUTPUT_BYTES

Maximum bytes any kernel of this axis returns.

fn dispatch_kernel( kernel_id: u32, input: &[u8], out: &mut [u8], ) -> Result<usize, ShapeViolation>

Dispatch the kernel identified by kernel_id against the evaluated input bytes. The implementation copies the kernel’s output into out and returns the written length.

impl Clone for Keccak256Hasher

fn clone(&self) -> Keccak256Hasher

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Keccak256Hasher

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

Formats the value using the given formatter.

impl Default for Keccak256Hasher

fn default() -> Keccak256Hasher

Returns the “default value” for a type.

impl HashAxis for Keccak256Hasher

const AXIS_ADDRESS: &'static str = "https://uor.foundation/axis/HashAxis/Keccak256"

const MAX_OUTPUT_BYTES: usize = KECCAK256_BYTES

fn hash(input: &[u8], out: &mut [u8]) -> Result<usize, ShapeViolation>

Compute the digest of input into out[..n], returning n.

impl Hasher for Keccak256Hasher

const OUTPUT_BYTES: usize = KECCAK256_BYTES

Active output width in bytes. Must lie within the bounds the application’s selected HostBounds declares — [<B as HostBounds>::FINGERPRINT_MIN_BYTES, FP_MAX].

fn initial() -> Keccak256Hasher

Initial hasher state.

fn fold_byte(self, b: u8) -> Keccak256Hasher

Fold a single byte into the running state.

fn fold_bytes(self, bytes: &[u8]) -> Keccak256Hasher

Fold a slice of bytes (default impl: byte-by-byte).

fn finalize(self) -> [u8; 32]

Finalize into the canonical max-width buffer of FP_MAX bytes. Bytes 0..OUTPUT_BYTES carry the hash result; bytes OUTPUT_BYTES..FP_MAX MUST be zero.

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for AddressModelKeccak256

type Input = Asn1Carrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelKeccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = AddressRouteKeccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for AddressModelKeccak256

type Input = CborCarrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelKeccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = AddressRouteKeccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for AddressModelKeccak256

type Input = CodeModuleCarrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelKeccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = AddressRouteKeccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for AddressModelKeccak256

type Input = GgufCarrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelKeccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = AddressRouteKeccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for AddressModelKeccak256

type Input = JsonCarrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelKeccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = AddressRouteKeccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for AddressModelKeccak256

type Input = OnnxCarrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelKeccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = AddressRouteKeccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for AddressModelKeccak256

type Input = RingElement

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelKeccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = AddressRouteKeccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for AddressModelKeccak256

type Input = SExprValue<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelKeccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = AddressRouteKeccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for AddressModelKeccak256

type Input = XmlValue<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = AddressLabelKeccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = AddressRouteKeccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for CompositionModelE6Keccak256

type Input = E6Carrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = CompositionLabelE6Keccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = CompositionRouteE6Keccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for CompositionModelE7Keccak256

type Input = E7Carrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = CompositionLabelE7Keccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = CompositionRouteE7Keccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for CompositionModelE8Keccak256

type Input = E8Carrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = CompositionLabelE8Keccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = CompositionRouteE8Keccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for CompositionModelF4Keccak256

type Input = F4Carrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = CompositionLabelF4Keccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = CompositionRouteF4Keccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<'a> PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, prism::pipeline::prism_model! { pub struct $model; pub struct $route; impl PrismModel< prism::vocabulary::DefaultHostTypes, $bounds, $hasher, $crate::resolvers::AddressResolverTuple<$hasher>, prism::pipeline::EmptyCommitment > for $model { type Input = $input; type Output = $shape; type Route = $route; fn route(input: Self::Input) -> Self::Output { $verb(input) } } }, AddressResolverTuple<Keccak256Hasher>> for CompositionModelG2Keccak256

type Input = G2Carrier<'a>

Input feature type — a [ConstrainedTypeShape] impl declared in foundation vocabulary. Per wiki ADR-023 (amended by ADR-060), Input is also bound by [IntoBindingValue]<'a> so [run_route] can flow the runtime input value (as a source-polymorphic TermValue carrier) into the CompileUnit binding table for Term::Variable { name_index: 0 } (the route’s input-parameter slot per ADR-022 D3 G2). The lifetime 'a is the borrowed-input-data lifetime the carrier (and the resulting Grounded<'a> output) propagates.

type Output = CompositionLabelG2Keccak256

Output label type — a [ConstrainedTypeShape] impl declared in foundation vocabulary that is also a [crate::enforcement::GroundedShape].

type Route = CompositionRouteG2Keccak256

Type-level witness of the term tree mapping Input to Output. Bound by [FoundationClosed]: the prism_model! macro emits the FoundationClosed impl for this witness iff every node is a foundation-vocabulary item, satisfying the closure check at the application’s compile time per UORassembly (TC-04).

fn forward( input: <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Input, ) -> Result<Grounded<'a, <Self as PrismModel<'a, DefaultHostTypes, AddrBounds, Keccak256Hasher, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }, AddressResolverTuple<Keccak256Hasher>, EmptyCommitment>>::Output, { _ }, { <crate::bounds::AddrBounds as ::uor_foundation::HostBounds>::FINGERPRINT_MAX_BYTES }>, PipelineFailure>

The catamorphism into [run_route]’s runtime carrier. Implementations are emitted by the prism_model! macro from the syntactic Route declaration; the macro derives the body via initiality of Term (wiki ADR-019). The canonical body is run_route::<H, B, A, Self>(input) (per ADR-022 D5).

impl<const INLINE_BYTES: usize> SubstrateTermBody<INLINE_BYTES> for Keccak256Hasher

fn body_arena() -> &'static [Term<'static, INLINE_BYTES>]

The Term arena the kernel decomposes to. Empty slice signals a primitive-fast-path axis whose body the implementation may evaluate through dispatch_kernel directly per ADR-055’s optional fast-path.