diff --git a/domain_test_service/domain/type.DomainOperator.html b/domain_test_service/domain/type.DomainOperator.html index c7ac30db50..76850bb5f0 100644 --- a/domain_test_service/domain/type.DomainOperator.html +++ b/domain_test_service/domain/type.DomainOperator.html @@ -1,7 +1,7 @@ DomainOperator in domain_test_service::domain - Rust

Type Alias domain_test_service::domain::DomainOperator

source · 
pub type DomainOperator<RuntimeApi> = DomainOperator<Block, Block, Client, RuntimeApi>;
Expand description

Domain executor for the test service.

Aliased Type§

struct DomainOperator<RuntimeApi> {
-    pub transaction_pool: Arc<BasicPool<FullChainApiWrapper<Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>>,
+    pub transaction_pool: Arc<BasicPool<FullChainApiWrapper<Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>>,
     pub keystore: Arc<dyn Keystore>,
     /* private fields */
-}

Fields§

§transaction_pool: Arc<BasicPool<FullChainApiWrapper<Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>>§keystore: Arc<dyn Keystore>
\ No newline at end of file +}

Fields§

§transaction_pool: Arc<BasicPool<FullChainApiWrapper<Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>>§keystore: Arc<dyn Keystore> \ No newline at end of file diff --git a/domain_test_service/domain/type.EvmDomainNode.html b/domain_test_service/domain/type.EvmDomainNode.html index b7948f68f5..1bf306735a 100644 --- a/domain_test_service/domain/type.EvmDomainNode.html +++ b/domain_test_service/domain/type.EvmDomainNode.html @@ -11,7 +11,7 @@ pub sync_service: Arc<SyncingService<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>>, pub addr: MultiaddrWithPeerId, pub rpc_handlers: RpcHandlers, - pub operator: Operator<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, BasicPool<FullChainApiWrapper<Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, + pub operator: Operator<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, BasicPool<FullChainApiWrapper<Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, pub tx_pool_sink: TracingUnboundedSender<ChainTxPoolMsg>, /* private fields */ }

Fields§

§domain_id: DomainId

The domain id

@@ -25,6 +25,6 @@
§addr: MultiaddrWithPeerId

The MultiaddrWithPeerId to this node. This is useful if you want to pass it as “boot node” to other nodes.

§rpc_handlers: RpcHandlers

RPCHandlers to make RPC queries.

-
§operator: Operator<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, BasicPool<FullChainApiWrapper<Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>

Domain oeprator.

+
§operator: Operator<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, BasicPool<FullChainApiWrapper<Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions), HostFunctions, HostFunctions, HostFunctions)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Client<Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, LocalCallExecutor<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>, RuntimeApi>>, Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, Backend<Block<Header<u32, BlakeTwo256>, OpaqueExtrinsic>>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>

Domain oeprator.

§tx_pool_sink: TracingUnboundedSender<ChainTxPoolMsg>

Sink to the node’s tx pool

\ No newline at end of file diff --git a/help.html b/help.html index eb0c3db08f..a0bb3ed0c0 100644 --- a/help.html +++ b/help.html @@ -1,2 +1,2 @@ -Help
-

Rustdoc help

Back
\ No newline at end of file +Help
+

Rustdoc help

Back
\ No newline at end of file diff --git a/index.html b/index.html index cf66d2097d..80fddc8140 100644 --- a/index.html +++ b/index.html @@ -1,2 +1,2 @@ -Index of crates
-

List of all crates

\ No newline at end of file +Index of crates
+

List of all crates

\ No newline at end of file diff --git a/pallet_domains/dispatchables/fn.submit_fraud_proof.html b/pallet_domains/dispatchables/fn.submit_fraud_proof.html index c677f8f0df..eb96b78ff1 100644 --- a/pallet_domains/dispatchables/fn.submit_fraud_proof.html +++ b/pallet_domains/dispatchables/fn.submit_fraud_proof.html @@ -1,6 +1,6 @@ submit_fraud_proof in pallet_domains::dispatchables - Rust

Function pallet_domains::dispatchables::submit_fraud_proof

source · 
pub fn submit_fraud_proof<T: Config>(
-    fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>
+    fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>
 )
Expand description

Warning: Doc-Only

This function is an automatically generated, and is doc-only, uncallable stub. See the real version in diff --git a/pallet_domains/enum.Call.html b/pallet_domains/enum.Call.html index 3d6023746d..8bd2f515c0 100644 --- a/pallet_domains/enum.Call.html +++ b/pallet_domains/enum.Call.html @@ -4,7 +4,7 @@ opaque_bundle: OpaqueBundleOf<T>, }, submit_fraud_proof { - fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>, + fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>, }, register_domain_runtime { runtime_name: String, @@ -54,7 +54,7 @@ // some variants omitted

}
Expand description

Contains a variant per dispatchable extrinsic that this pallet has.

Variants§

§

submit_bundle

Fields

§opaque_bundle: OpaqueBundleOf<T>

See Pallet::submit_bundle.

-
§

submit_fraud_proof

Fields

§fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>

See Pallet::submit_fraud_proof.

+
§

submit_fraud_proof

Fields

§fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>

See Pallet::submit_fraud_proof.

§

register_domain_runtime

Fields

§runtime_name: String
§runtime_type: RuntimeType
§raw_genesis_storage: Vec<u8>

See Pallet::register_domain_runtime.

§

upgrade_domain_runtime

Fields

§runtime_id: RuntimeId
§raw_genesis_storage: Vec<u8>

See Pallet::upgrade_domain_runtime.

§

register_operator

Fields

§domain_id: DomainId
§amount: <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance
§config: OperatorConfig<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>

See Pallet::register_operator.

@@ -69,7 +69,7 @@
§

force_staking_epoch_transition

Fields

§domain_id: DomainId

See Pallet::force_staking_epoch_transition.

Implementations§

source§

impl<T: Config> Call<T>

source

pub fn new_call_variant_submit_bundle(opaque_bundle: OpaqueBundleOf<T>) -> Self

Create a call with the variant submit_bundle.

source

pub fn new_call_variant_submit_fraud_proof( - fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>> + fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>> ) -> Self

Create a call with the variant submit_fraud_proof.

source

pub fn new_call_variant_register_domain_runtime( runtime_name: String, @@ -127,7 +127,7 @@ sufficient, and should not be overridden without very good reason.

source§

impl<T> TypeInfo for Call<T>
where PhantomData<(T,)>: TypeInfo + 'static, OpaqueBundleOf<T>: TypeInfo + 'static, - Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>: TypeInfo + 'static, + Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>: TypeInfo + 'static, <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: TypeInfo + 'static, OperatorConfig<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static, DomainConfig<T::AccountId>: TypeInfo + 'static, diff --git a/pallet_domains/struct.Pallet.html b/pallet_domains/struct.Pallet.html index 1f113cfc3a..8a3b42a54f 100644 --- a/pallet_domains/struct.Pallet.html +++ b/pallet_domains/struct.Pallet.html @@ -6,7 +6,7 @@ opaque_bundle: OpaqueBundleOf<T> ) -> DispatchResultWithPostInfo

source

pub fn submit_fraud_proof( origin: OriginFor<T>, - fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>> + fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>> ) -> DispatchResult

source

pub fn register_domain_runtime( origin: OriginFor<T>, runtime_name: String, @@ -108,7 +108,7 @@ ) -> Option<ReceiptHashFor<T>>

source§

impl<T> Pallet<T>
where T: Config + SendTransactionTypes<Call<T>>,

source

pub fn submit_bundle_unsigned(opaque_bundle: OpaqueBundleOf<T>)

Submits an unsigned extrinsic Call::submit_bundle.

source

pub fn submit_fraud_proof_unsigned( - fraud_proof: FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader> + fraud_proof: FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader> )

Submits an unsigned extrinsic Call::submit_fraud_proof.

Trait Implementations§

source§

impl<T: Config> BeforeAllRuntimeMigrations for Pallet<T>

source§

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.
source§

impl<T: Config> Callable<T> for Pallet<T>

§

type RuntimeCall = Call<T>

source§

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<T> Debug for Pallet<T>

source§

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

Formats the value using the given formatter. Read more
source§

impl<T: Config> GetStorageVersion for Pallet<T>

§

type CurrentStorageVersion = StorageVersion

This will be filled out by the pallet macro. Read more
source§

fn current_storage_version() -> Self::CurrentStorageVersion

Returns the current storage version as supported by the pallet.
source§

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.
source§

impl<T: Config> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(block_number: BlockNumberFor<T>) -> Weight

Block initialization hook. This is called at the very beginning of block execution. Read more
source§

fn on_finalize(_: BlockNumberFor<T>)

Block finalization hook. This is called at the very end of block execution. Read more
§

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before [Hooks::on_finalize]). Read more
§

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by FRAME. Read more
§

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are diff --git a/pallet_rewards/trait.Config.html b/pallet_rewards/trait.Config.html index b8c03ae43c..4268e82e73 100644 --- a/pallet_rewards/trait.Config.html +++ b/pallet_rewards/trait.Config.html @@ -4,8 +4,8 @@ type Currency: Currency<Self::AccountId>; type BlockReward: Get<<<Self as Config>::Currency as Currency<<Self as Config>::AccountId>>::Balance>; type VoteReward: Get<<<Self as Config>::Currency as Currency<<Self as Config>::AccountId>>::Balance>; - type FindBlockRewardAddress: FindBlockRewardAddress<Self::AccountId>; - type FindVotingRewardAddresses: FindVotingRewardAddresses<Self::AccountId>; + type FindBlockRewardAddress: FindBlockRewardAddress<Self::AccountId>; + type FindVotingRewardAddresses: FindVotingRewardAddresses<Self::AccountId>; type WeightInfo: WeightInfo; type OnReward: OnReward<Self::AccountId, <<Self as Config>::Currency as Currency<<Self as Config>::AccountId>>::Balance>; }
Expand description

Configuration trait of this pallet.

@@ -16,4 +16,4 @@

Required Associated Types§

source

type RuntimeEvent: From<Event<Self>> + IsType<<Self as Config>::RuntimeEvent>

pallet-rewards events

source

type Currency: Currency<Self::AccountId>

source

type BlockReward: Get<<<Self as Config>::Currency as Currency<<Self as Config>::AccountId>>::Balance>

Fixed reward for block producer.

source

type VoteReward: Get<<<Self as Config>::Currency as Currency<<Self as Config>::AccountId>>::Balance>

Fixed reward for voter.

-
source

type FindBlockRewardAddress: FindBlockRewardAddress<Self::AccountId>

source

type FindVotingRewardAddresses: FindVotingRewardAddresses<Self::AccountId>

source

type WeightInfo: WeightInfo

source

type OnReward: OnReward<Self::AccountId, <<Self as Config>::Currency as Currency<<Self as Config>::AccountId>>::Balance>

Object Safety§

This trait is not object safe.

Implementors§

\ No newline at end of file +
source

type FindBlockRewardAddress: FindBlockRewardAddress<Self::AccountId>

source

type FindVotingRewardAddresses: FindVotingRewardAddresses<Self::AccountId>

source

type WeightInfo: WeightInfo

source

type OnReward: OnReward<Self::AccountId, <<Self as Config>::Currency as Currency<<Self as Config>::AccountId>>::Balance>

Object Safety§

This trait is not object safe.

Implementors§

\ No newline at end of file diff --git a/pallet_subspace/pallet/struct.Pallet.html b/pallet_subspace/pallet/struct.Pallet.html index 6202f1a3fe..67849cdbfb 100644 --- a/pallet_subspace/pallet/struct.Pallet.html +++ b/pallet_subspace/pallet/struct.Pallet.html @@ -61,7 +61,7 @@ signed_vote: SignedVote<BlockNumberFor<T>, T::Hash, T::AccountId> )

Submit farmer vote vote that is essentially a header with bigger solution range than acceptable for block authoring.

-

Trait Implementations§

source§

impl<T: Config> BeforeAllRuntimeMigrations for Pallet<T>

source§

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.
source§

impl<T: Config> Callable<T> for Pallet<T>

§

type RuntimeCall = Call<T>

source§

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<T> Debug for Pallet<T>

source§

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

Formats the value using the given formatter. Read more
source§

impl<T: Config> FindBlockRewardAddress<<T as Config>::AccountId> for Pallet<T>

source§

fn find_block_reward_address() -> Option<T::AccountId>

Find the address for a block rewards based on the pre-runtime digests.
source§

impl<T: Config> FindVotingRewardAddresses<<T as Config>::AccountId> for Pallet<T>

source§

fn find_voting_reward_addresses() -> Vec<T::AccountId>

Find the addresses for voting rewards based on transactions found in the block.
source§

impl<T: Config> GetStorageVersion for Pallet<T>

§

type CurrentStorageVersion = NoStorageVersionSet

This will be filled out by the pallet macro. Read more
source§

fn current_storage_version() -> Self::CurrentStorageVersion

Returns the current storage version as supported by the pallet.
source§

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.
source§

impl<T: Config> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(block_number: BlockNumberFor<T>) -> Weight

Block initialization hook. This is called at the very beginning of block execution. Read more
source§

fn on_finalize(block_number: BlockNumberFor<T>)

Block finalization hook. This is called at the very end of block execution. Read more
§

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before +

Trait Implementations§

source§

impl<T: Config> BeforeAllRuntimeMigrations for Pallet<T>

source§

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.
source§

impl<T: Config> Callable<T> for Pallet<T>

§

type RuntimeCall = Call<T>

source§

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl<T> Debug for Pallet<T>

source§

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

Formats the value using the given formatter. Read more
source§

impl<T: Config> FindBlockRewardAddress<<T as Config>::AccountId> for Pallet<T>

source§

fn find_block_reward_address() -> Option<T::AccountId>

Find the address for a block rewards based on the pre-runtime digests.
source§

impl<T: Config> FindVotingRewardAddresses<<T as Config>::AccountId> for Pallet<T>

source§

fn find_voting_reward_addresses() -> Vec<T::AccountId>

Find the addresses for voting rewards based on transactions found in the block.
source§

impl<T: Config> GetStorageVersion for Pallet<T>

§

type CurrentStorageVersion = NoStorageVersionSet

This will be filled out by the pallet macro. Read more
source§

fn current_storage_version() -> Self::CurrentStorageVersion

Returns the current storage version as supported by the pallet.
source§

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.
source§

impl<T: Config> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(block_number: BlockNumberFor<T>) -> Weight

Block initialization hook. This is called at the very beginning of block execution. Read more
source§

fn on_finalize(block_number: BlockNumberFor<T>)

Block finalization hook. This is called at the very end of block execution. Read more
§

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before [Hooks::on_finalize]). Read more
§

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by FRAME. Read more
§

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are dispatched as separate threads, and entirely independent of the main wasm runtime. Read more
§

fn integrity_test()

Check the integrity of this pallet’s configuration. Read more
source§

impl<T: Config> IntegrityTest for Pallet<T>

source§

fn integrity_test()

See [Hooks::integrity_test].
source§

impl<T: Config> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn offchain_worker(n: BlockNumberFor<T>)

This function is being called after every block import (when fully synced). Read more
source§

impl<T: Config> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_finalize(n: BlockNumberFor<T>)

See [Hooks::on_finalize].
source§

impl<T: Config> OnGenesis for Pallet<T>

source§

fn on_genesis()

Something that should happen at genesis.
source§

impl<T: Config> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_idle(n: BlockNumberFor<T>, remaining_weight: Weight) -> Weight

See [Hooks::on_idle].
source§

impl<T: Config> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(n: BlockNumberFor<T>) -> Weight

See [Hooks::on_initialize].
source§

impl<T: Config> OnOffenceHandler<Public> for Pallet<T>

source§

fn on_offence(offenders: &[OffenceDetails<FarmerPublicKey>])

A handler for an offence of a particular kind. Read more
source§

impl<T: Config> OnRuntimeUpgrade for Pallet<T>

source§

fn on_runtime_upgrade() -> Weight

See [Hooks::on_runtime_upgrade].
source§

impl<T: Config> PalletInfoAccess for Pallet<T>

source§

fn index() -> usize

Index of the pallet as configured in the runtime.
source§

fn name() -> &'static str

Name of the pallet as configured in the runtime.
source§

fn name_hash() -> [u8; 16]

Two128 hash of name.
source§

fn module_name() -> &'static str

Name of the Rust module containing the pallet.
source§

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.
source§

impl<T: Config> PalletsInfoAccess for Pallet<T>

source§

fn count() -> usize

The number of pallets’ information that this type represents. Read more
source§

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.
source§

impl<T> PartialEq for Pallet<T>

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always diff --git a/sc_consensus_subspace/archiver/fn.create_subspace_archiver.html b/sc_consensus_subspace/archiver/fn.create_subspace_archiver.html index c1d5b1c866..6513854be1 100644 --- a/sc_consensus_subspace/archiver/fn.create_subspace_archiver.html +++ b/sc_consensus_subspace/archiver/fn.create_subspace_archiver.html @@ -1,5 +1,5 @@ create_subspace_archiver in sc_consensus_subspace::archiver - Rust
-

Function sc_consensus_subspace::archiver::create_subspace_archiver

source · 
pub fn create_subspace_archiver<Block, Backend, Client, AS, SO>(
+    
Function sc_consensus_subspace::archiver::create_subspace_archiver
source · 
pub fn create_subspace_archiver<Block, Backend, Client, AS, SO>(
     segment_headers_store: SegmentHeadersStore<AS>,
     subspace_link: &SubspaceLink<Block>,
     client: Arc<Client>,
@@ -9,7 +9,7 @@
     Block: BlockT,
     Backend: BackendT<Block>,
     Client: ProvideRuntimeApi<Block> + BlockBackend<Block> + HeaderBackend<Block> + LockImportRun<Block, Backend> + Finalizer<Block, Backend> + AuxStore + Send + Sync + 'static,
-    Client::Api: SubspaceApi<Block, FarmerPublicKey> + ObjectsApi<Block>,
+    Client::Api: SubspaceApi<Block, FarmerPublicKey> + ObjectsApi<Block>,
     AS: AuxStore + Send + Sync + 'static,
     SO: SyncOracle + Send + Sync + 'static,
Expand description

Crate an archiver task that will listen for importing blocks and archive blocks at K depth, producing pieces and segment headers (segment headers are then added back to the blockchain as diff --git a/sc_consensus_subspace/archiver/fn.decode_block.html b/sc_consensus_subspace/archiver/fn.decode_block.html index 5244e151b6..0f409d48b4 100644 --- a/sc_consensus_subspace/archiver/fn.decode_block.html +++ b/sc_consensus_subspace/archiver/fn.decode_block.html @@ -1,5 +1,5 @@ decode_block in sc_consensus_subspace::archiver - Rust

-

Function sc_consensus_subspace::archiver::decode_block

source · 
pub fn decode_block<Block>(
+    
Function sc_consensus_subspace::archiver::decode_block
source · 
pub fn decode_block<Block>(
     encoded_block: &[u8]
 ) -> Result<SignedBlock<Block>, Error>
where
     Block: BlockT,
Expand description
Symmetrical to encode_block(), used to decode previously encoded blocks

diff --git a/sc_consensus_subspace/archiver/fn.encode_block.html b/sc_consensus_subspace/archiver/fn.encode_block.html
index d90c64fc4c..b64185070b 100644
--- a/sc_consensus_subspace/archiver/fn.encode_block.html
+++ b/sc_consensus_subspace/archiver/fn.encode_block.html
@@ -1,5 +1,5 @@
 encode_block in sc_consensus_subspace::archiver - Rust

-    
Function sc_consensus_subspace::archiver::encode_block
source · 
pub fn encode_block<Block>(signed_block: SignedBlock<Block>) -> Vec<u8> ⓘ
where
+    
Function sc_consensus_subspace::archiver::encode_block
source · 
pub fn encode_block<Block>(signed_block: SignedBlock<Block>) -> Vec<u8> ⓘ
where
     Block: BlockT,
Expand description
Encode block for archiving purposes.

 
Only specific Subspace justifications are included in the encoding, determined by result of
 SubspaceJustification::must_be_archived, other justifications are filtered-out.

diff --git a/sc_consensus_subspace/archiver/fn.recreate_genesis_segment.html b/sc_consensus_subspace/archiver/fn.recreate_genesis_segment.html
index 791b02af09..b959e68de9 100644
--- a/sc_consensus_subspace/archiver/fn.recreate_genesis_segment.html
+++ b/sc_consensus_subspace/archiver/fn.recreate_genesis_segment.html
@@ -1,9 +1,9 @@
 recreate_genesis_segment in sc_consensus_subspace::archiver - Rust

-    
Function sc_consensus_subspace::archiver::recreate_genesis_segment
source · 
pub fn recreate_genesis_segment<Block, Client>(
+    
Function sc_consensus_subspace::archiver::recreate_genesis_segment
source · 
pub fn recreate_genesis_segment<Block, Client>(
     client: &Client,
     kzg: Kzg
 ) -> Result<Option<NewArchivedSegment>, Box<dyn Error>>
where
     Block: BlockT,
     Client: ProvideRuntimeApi<Block> + BlockBackend<Block> + HeaderBackend<Block>,
-    Client::Api: ObjectsApi<Block>,
Expand description
Derive genesis segment on demand, returns Ok(None) in case genesis block was already pruned

+    Client::Api: ObjectsApi<Block>,
Expand description
Derive genesis segment on demand, returns Ok(None) in case genesis block was already pruned

 

\ No newline at end of file
diff --git a/sc_consensus_subspace/archiver/index.html b/sc_consensus_subspace/archiver/index.html
index 474173d16d..cf0cebc903 100644
--- a/sc_consensus_subspace/archiver/index.html
+++ b/sc_consensus_subspace/archiver/index.html
@@ -1,5 +1,5 @@
 sc_consensus_subspace::archiver - Rust

-    
Module sc_consensus_subspace::archiver
source · 
Expand description
Consensus archiver responsible for archival of blockchain history, it is driven by block import
+    
Module sc_consensus_subspace::archiver
source · 
Expand description
Consensus archiver responsible for archival of blockchain history, it is driven by block import
 pipeline.

 
Implements archiving process in Subspace blockchain that converts blockchain history (blocks)
 into archived history (pieces).

diff --git a/sc_consensus_subspace/archiver/struct.ArchivedSegmentNotification.html b/sc_consensus_subspace/archiver/struct.ArchivedSegmentNotification.html
index 1c2d59c712..a3310a1cd7 100644
--- a/sc_consensus_subspace/archiver/struct.ArchivedSegmentNotification.html
+++ b/sc_consensus_subspace/archiver/struct.ArchivedSegmentNotification.html
@@ -1,12 +1,12 @@
 ArchivedSegmentNotification in sc_consensus_subspace::archiver - Rust

-    
Struct sc_consensus_subspace::archiver::ArchivedSegmentNotification
source · 
pub struct ArchivedSegmentNotification {
+    
Struct sc_consensus_subspace::archiver::ArchivedSegmentNotification
source · 
pub struct ArchivedSegmentNotification {
     pub archived_segment: Arc<NewArchivedSegment>,
     pub acknowledgement_sender: TracingUnboundedSender<()>,
 }
Expand description
Notification with block header hash that needs to be signed and sender for signature.

 
Fields§
§archived_segment: Arc<NewArchivedSegment>
Archived segment.

 
§acknowledgement_sender: TracingUnboundedSender<()>
Sender that signified the fact of receiving archived segment by farmer.

 
This must be used to send a message or else block import pipeline will get stuck.

-
Trait Implementations§
source§
impl Clone for ArchivedSegmentNotification
source§
fn clone(&self) -> ArchivedSegmentNotification
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
source§
impl Debug for ArchivedSegmentNotification
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
+
Trait Implementations§
source§
impl Clone for ArchivedSegmentNotification
source§
fn clone(&self) -> ArchivedSegmentNotification
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
source§
impl Debug for ArchivedSegmentNotification
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
     T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
§
impl<T> Any for T
where
     T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
§
fn type_name(&self) -> &'static str
§
impl<T> AnySync for T
where
     T: Any + Send + Sync,
§
fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>
source§
impl<T> Borrow<T> for T
where
diff --git a/sc_consensus_subspace/archiver/struct.SegmentHeadersStore.html b/sc_consensus_subspace/archiver/struct.SegmentHeadersStore.html
index f378c95419..e5edc1bd18 100644
--- a/sc_consensus_subspace/archiver/struct.SegmentHeadersStore.html
+++ b/sc_consensus_subspace/archiver/struct.SegmentHeadersStore.html
@@ -1,5 +1,5 @@
 SegmentHeadersStore in sc_consensus_subspace::archiver - Rust

-    
Struct sc_consensus_subspace::archiver::SegmentHeadersStore
source · 
pub struct SegmentHeadersStore<AS> { /* private fields */ }
Expand description
Persistent storage of segment headers.

+    
Struct sc_consensus_subspace::archiver::SegmentHeadersStore
source · 
pub struct SegmentHeadersStore<AS> { /* private fields */ }
Expand description
Persistent storage of segment headers.

 
It maintains all known segment headers. During sync from DSN it is possible that this data structure contains
 segment headers that from the point of view of the tip of the current chain are “in the future”. This is expected
 and must be accounted for in the archiver and other places.

@@ -7,19 +7,19 @@
 distinct segment headers with monotonically increasing segment indices. During instantiation all previously stored
 batches will be read and in-memory representation of the whole contents will be created such that queries to this
 data structure are quick and not involving any disk I/O.

-
Implementations§
source§
impl<AS> SegmentHeadersStore<AS>
where
-    AS: AuxStore,
source
pub fn new(aux_store: Arc<AS>) -> Result<Self>
Create new instance

-
source
pub fn max_segment_index(&self) -> Option<SegmentIndex>
Returns last observed segment index

-
source
pub fn add_segment_headers(
+
Implementations§
source§
impl<AS> SegmentHeadersStore<AS>
where
+    AS: AuxStore,
source
pub fn new(aux_store: Arc<AS>) -> Result<Self>
Create new instance

+
source
pub fn max_segment_index(&self) -> Option<SegmentIndex>
Returns last observed segment index

+
source
pub fn add_segment_headers(
     &self,
     segment_headers: &[SegmentHeader]
 ) -> Result<()>
Add segment headers.

 
Multiple can be inserted for efficiency purposes.

-
source
pub fn get_segment_header(
+
source
pub fn get_segment_header(
     &self,
     segment_index: SegmentIndex
 ) -> Option<SegmentHeader>
Get a single segment header

-
Trait Implementations§
source§
impl<AS> Clone for SegmentHeadersStore<AS>
source§
fn clone(&self) -> Self
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
source§
impl<AS: Debug> Debug for SegmentHeadersStore<AS>
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Auto Trait Implementations§
§
impl<AS> !RefUnwindSafe for SegmentHeadersStore<AS>
§
impl<AS> Send for SegmentHeadersStore<AS>
where
+
Trait Implementations§
source§
impl<AS> Clone for SegmentHeadersStore<AS>
source§
fn clone(&self) -> Self
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
source§
impl<AS: Debug> Debug for SegmentHeadersStore<AS>
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Auto Trait Implementations§
§
impl<AS> !RefUnwindSafe for SegmentHeadersStore<AS>
§
impl<AS> Send for SegmentHeadersStore<AS>
where
     AS: Sync + Send,
§
impl<AS> Sync for SegmentHeadersStore<AS>
where
     AS: Sync + Send,
§
impl<AS> Unpin for SegmentHeadersStore<AS>
§
impl<AS> !UnwindSafe for SegmentHeadersStore<AS>
Blanket Implementations§
source§
impl<T> Any for T
where
     T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
§
impl<T> Any for T
where
diff --git a/sc_consensus_subspace/index.html b/sc_consensus_subspace/index.html
index dc48eb25a2..8d02543b94 100644
--- a/sc_consensus_subspace/index.html
+++ b/sc_consensus_subspace/index.html
@@ -1,6 +1,6 @@
 sc_consensus_subspace - Rust

-    
Crate sc_consensus_subspace
source · 
Expand description
sc-consensus-subspace is the core of Subspace consensus implementation.

+    
Crate sc_consensus_subspace
source · 
Expand description
sc-consensus-subspace is the core of Subspace consensus implementation.

 
You should familiarize yourself with Subnomicon and, ideally, protocol
 specifications. Documentation here assumes decent prior knowledge of the protocol on conceptual level and will not
 explain how the protocol works, it will instead explain how the protocol is implemented.

diff --git a/sc_consensus_subspace/struct.SubspaceLink.html b/sc_consensus_subspace/struct.SubspaceLink.html
index a683933074..a78bf287a1 100644
--- a/sc_consensus_subspace/struct.SubspaceLink.html
+++ b/sc_consensus_subspace/struct.SubspaceLink.html
@@ -1,29 +1,29 @@
 SubspaceLink in sc_consensus_subspace - Rust

-    
Struct sc_consensus_subspace::SubspaceLink
source · 
pub struct SubspaceLink<Block: BlockT> { /* private fields */ }
Expand description
State that must be shared between various consensus components.

-
Implementations§
source§
impl<Block: BlockT> SubspaceLink<Block>
source
pub fn new(chain_constants: ChainConstants, kzg: Kzg) -> Self
Create new instance.

-
source
pub fn new_slot_notification_stream(
+    
Struct sc_consensus_subspace::SubspaceLink
source · 
pub struct SubspaceLink<Block: BlockT> { /* private fields */ }
Expand description
State that must be shared between various consensus components.

+
Implementations§
source§
impl<Block: BlockT> SubspaceLink<Block>
source
pub fn new(chain_constants: ChainConstants, kzg: Kzg) -> Self
Create new instance.

+
source
pub fn new_slot_notification_stream(
     &self
 ) -> SubspaceNotificationStream<NewSlotNotification>
Get stream with notifications about new slot arrival with ability to send solution back.

-
source
pub fn reward_signing_notification_stream(
+
source
pub fn reward_signing_notification_stream(
     &self
 ) -> SubspaceNotificationStream<RewardSigningNotification>
A stream with notifications about headers that need to be signed with ability to send
 signature back.

-
source
pub fn archived_segment_notification_stream(
+
source
pub fn archived_segment_notification_stream(
     &self
 ) -> SubspaceNotificationStream<ArchivedSegmentNotification>
Get stream with notifications about archived segment creation

-
source
pub fn block_importing_notification_stream(
+
source
pub fn block_importing_notification_stream(
     &self
 ) -> SubspaceNotificationStream<BlockImportingNotification<Block>>
Get stream with notifications about each imported block right BEFORE import actually
 happens.

 
NOTE: all Subspace checks have already happened for this block, but block can still
 potentially fail to import in Substrate’s internals.

-
source
pub fn segment_headers_for_block(
+
source
pub fn segment_headers_for_block(
     &self,
     block_number: NumberFor<Block>
 ) -> Vec<SegmentHeader>
Get blocks that are expected to be included at specified block number.

-
source
pub fn chain_constants(&self) -> &ChainConstants
Subspace chain constants.

-
source
pub fn kzg(&self) -> &Kzg
Access KZG instance

-
Trait Implementations§
source§
impl<Block: Clone + BlockT> Clone for SubspaceLink<Block>
source§
fn clone(&self) -> SubspaceLink<Block>
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
Auto Trait Implementations§
§
impl<Block> !RefUnwindSafe for SubspaceLink<Block>
§
impl<Block> Send for SubspaceLink<Block>
§
impl<Block> Sync for SubspaceLink<Block>
§
impl<Block> Unpin for SubspaceLink<Block>
§
impl<Block> !UnwindSafe for SubspaceLink<Block>
Blanket Implementations§
source§
impl<T> Any for T
where
+
source
pub fn chain_constants(&self) -> &ChainConstants
Subspace chain constants.

+
source
pub fn kzg(&self) -> &Kzg
Access KZG instance

+
Trait Implementations§
source§
impl<Block: Clone + BlockT> Clone for SubspaceLink<Block>
source§
fn clone(&self) -> SubspaceLink<Block>
Returns a copy of the value. Read more
1.0.0 · source§
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source. Read more
Auto Trait Implementations§
§
impl<Block> !RefUnwindSafe for SubspaceLink<Block>
§
impl<Block> Send for SubspaceLink<Block>
§
impl<Block> Sync for SubspaceLink<Block>
§
impl<Block> Unpin for SubspaceLink<Block>
§
impl<Block> !UnwindSafe for SubspaceLink<Block>
Blanket Implementations§
source§
impl<T> Any for T
where
     T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
§
impl<T> Any for T
where
     T: Any,
§
fn into_any(self: Box<T>) -> Box<dyn Any>
§
fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>
§
fn type_name(&self) -> &'static str
§
impl<T> AnySync for T
where
     T: Any + Send + Sync,
§
fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>
source§
impl<T> Borrow<T> for T
where
diff --git a/search-index.js b/search-index.js
index ffe1a80dcf..d6d636be46 100644
--- a/search-index.js
+++ b/search-index.js
@@ -43,7 +43,7 @@ var searchIndex = new Map(JSON.parse('[\
 ["sp_objects",{"doc":"Primitives for Objects.","t":"KNN","n":["ObjectsApi","extract_block_object_mapping","validated_object_call_hashes"],"q":[[0,"sp_objects"],[3,"subspace_runtime_primitives"],[4,"alloc::vec"],[5,"subspace_core_primitives::objects"],[6,"sp_api"],[7,"core::result"],[8,"sp_runtime::traits"]],"d":["","Extract block object mapping for a given block","Returns all the validated object call hashes for a given …"],"i":[0,1,1],"f":"`{{bc{f{d}}}{{l{hj}}}n}{b{{l{{f{d}}j}}}}","c":[],"p":[[10,"ObjectsApi",0],[8,"Hash",3],[5,"Vec",4],[5,"BlockObjectMapping",5],[6,"ApiError",6],[6,"Result",7],[10,"Block",8]],"b":[]}],\
 ["sp_subspace_mmr",{"doc":"Primitives for Subspace MMR.","t":"FFKGGPPNNNMOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNCNNNNNNMNNNOCNNNNNNNNNNNNNNNNNNNNNNNNNNNFKFNNNNNNNNNNNNNNNNNNNNMNNNNNNNNNNNNNNNNNNNNFNNNNNNNNHNNNNNNNNNN","n":["HostFunctions","LeafDataV0","MmrDigest","MmrDigestItem","MmrLeaf","NewMmrRoot","V0","__clone_box","__clone_box","__clone_box","as_new_mmr_root","block_hash","block_number","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","decode","decode","decode","decode_all","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","deref","deref","deref","deref_mut","deref_mut","deref_mut","drop","drop","drop","encode_to","encode_to","encode_to","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","extrinsics_root","fmt","fmt","from","from","from","from_mut","from_mut","from_mut","from_ref","from_ref","from_ref","host_functions","init","init","init","into","into","into","new_mmr_root","size_hint","size_hint","size_hint","state_root","subspace_mmr_runtime_interface","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","type_info","type_info","type_info","unchecked_into","unchecked_into","unchecked_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","vzip","vzip","vzip","SubspaceMmrExtension","SubspaceMmrHostFunctions","SubspaceMmrHostFunctionsImpl","as_mut_any","borrow","borrow","borrow_mut","borrow_mut","deref","deref","deref","deref_mut","deref_mut","deref_mut","drop","drop","from","from","from","from_mut","from_mut","from_ref","from_ref","get_mmr_leaf_data","get_mmr_leaf_data","init","init","into","into","new","new","try_from","try_from","try_into","try_into","type_id","type_id","type_id","unchecked_into","unchecked_into","unique_saturated_into","unique_saturated_into","vzip","vzip","HostFunctions","borrow","borrow_mut","deref","deref_mut","drop","from","from_mut","from_ref","get_mmr_leaf_data","host_functions","init","into","register_static","try_from","try_into","type_id","unchecked_into","unique_saturated_into","vzip"],"q":[[0,"sp_subspace_mmr"],[113,"sp_subspace_mmr::host_functions"],[157,"sp_subspace_mmr::subspace_mmr_runtime_interface"],[177,"dyn_clone::sealed"],[178,"core::option"],[179,"core::clone"],[180,"parity_scale_codec::codec"],[181,"parity_scale_codec::error"],[182,"core::result"],[183,"parity_scale_codec::codec"],[184,"parity_scale_codec::codec"],[185,"core::fmt"],[186,"core::fmt"],[187,"core::any"],[188,"scale_info::ty"],[189,"core::any"],[190,"primitive_types"],[191,"sp_runtime::traits"],[192,"sp_blockchain::backend"],[193,"sp_wasm_interface"],[194,"sp_wasm_interface"]],"d":["Provides implementations for the extern host functions.","MMR v0 leaf data","MMR specific digest items interface.","MMR specific digest item.","MMR leaf structure","","V0 version of leaf data","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Can be used to prove block body","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Get a mutable reference to the inner from the outer.","Get a mutable reference to the inner from the outer.","Get a mutable reference to the inner from the outer.","Get a reference to the inner from the outer.","Get a reference to the inner from the outer.","Get a reference to the inner from the outer.","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","","","","","Can be used to prove specific storage after block was …","MMR related runtime interface","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Trait to query MMR specific data through host function..","Implementation of MMR host function.","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","Get a mutable reference to the inner from the outer.","Get a mutable reference to the inner from the outer.","Get a reference to the inner from the outer.","Get a reference to the inner from the outer.","Returns the MMR Leaf data for given consensus block hash","","","","Calls U::from(self).","Calls U::from(self).","","Create a new instance of SubspaceMmrExtension.","","","","","","","","","","","","","","Provides implementations for the extern host functions.","","","","","","Returns the argument unchanged.","Get a mutable reference to the inner from the outer.","Get a reference to the inner from the outer.","Returns the MMR leaf.","","","Calls U::from(self).","","","","","","",""],"i":[0,0,0,0,0,8,5,5,7,8,3,7,7,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,5,5,7,7,7,8,8,8,7,5,7,5,7,8,5,7,8,5,7,8,0,5,7,8,5,7,8,3,5,7,8,7,0,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,5,7,8,0,0,0,29,34,29,34,29,34,29,29,34,29,29,34,29,34,29,29,34,29,34,29,31,34,34,29,34,29,34,29,34,29,34,29,34,29,29,34,29,34,29,34,29,0,39,39,39,39,39,39,39,39,0,39,39,39,39,39,39,39,39,39,39],"f":"```````{{cb}d{}}00{f{{h{c}}}{}}``{ce{}{}}00000{{{j{ce}}}{{j{ce}}}ll}{{{n{ce}}}{{n{ce}}}ll}{{{A`{c}}}{{A`{c}}}{lAb}}{{ce}d{}{}}00{c{{Af{{j{eg}}Ad}}}Ah{}{}}{c{{Af{{n{eg}}Ad}}}AhAjAj}{c{{Af{{A`{e}}Ad}}}Ah{AjAb}}{{{An{Al}}}{{Af{cAd}}}{}}00{{B`{An{Al}}}{{Af{cAd}}}{}}00{{B`c}{{Af{eAd}}}Ah{}}00{Bbc{}}00000{Bbd}00{{{j{ce}}g}d{}{}{BdBf}}{{{n{ce}}g}dBhBh{BdBf}}{{{A`{c}}e}d{BhAb}{BdBf}}{{{j{ce}}{j{ce}}}BjBlBl}{{{n{ce}}{n{ce}}}BjBlBl}{{{A`{c}}{A`{c}}}Bj{BlAb}}{{ce}Bj{}{}}00000000`{{{j{ce}}Bn}C`CbCb}{{{n{ce}}Bn}C`CbCb}{cc{}}00{ce{}{}}00000`{{}Bb}00111{cf{}}{{{j{ce}}}Bb{}{}}{{{n{ce}}}BbBhBh}{{{A`{c}}}Bb{BhAb}}``{{c{An{Al}}}{{Cd{Al}}}{}}00666{c{{Af{e}}}{}{}}00000{cCf{}}00{{}Ch}00999999999```{CjCl}::::{Bbc{}}{Cjc{}}1101{Bbd}0>>{{{D`{Cn}}}Cj}>>>>{{CnDb}{{h{`}}}}{{{Dd{ce}}Db}{{h{`}}}Df{{Dh{c}}}}??{ce{}{}}0{{{D`{c}}}{{Dd{ec}}}{}{}}4;;;;::{CjCf}222222`22886{cc{}}33{Db{{h{`}}}}{{}{{Cd{Dj}}}}{{}Bb}6{c{{Af{d}}}Dl}{c{{Af{e}}}{}{}}0{cCf{}}999","c":[],"p":[[5,"Private",177],[1,"unit"],[10,"MmrDigest",0],[6,"Option",178],[6,"MmrLeaf",0],[10,"Clone",179],[5,"LeafDataV0",0],[6,"MmrDigestItem",0],[10,"Codec",180],[5,"Error",181],[6,"Result",182],[10,"Input",180],[10,"Decode",180],[1,"u8"],[1,"slice"],[1,"u32"],[1,"usize"],[10,"Output",180],[10,"Sized",183],[10,"Encode",180],[1,"bool"],[10,"PartialEq",184],[5,"Formatter",185],[8,"Result",185],[10,"Debug",185],[5,"Vec",186],[5,"TypeId",187],[5,"Type",188],[5,"SubspaceMmrExtension",113],[10,"Any",187],[10,"SubspaceMmrHostFunctions",113],[5,"Arc",189],[5,"H256",190],[5,"SubspaceMmrHostFunctionsImpl",113],[10,"Block",191],[10,"HeaderBackend",192],[10,"Function",193],[10,"HostFunctionRegistry",193],[5,"HostFunctions",157]],"b":[]}],\
 ["subspace_archiving",{"doc":"Collection of modules used for dealing with archived state …","t":"CCCFGPPPPPPFPPGGPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHHNNONOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOPPPPFGGNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNPPPFFGGPNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNOO","n":["archiver","piece_reconstructor","reconstructor","Archiver","ArchiverInstantiationError","Block","BlockContinuation","BlockStart","FailedToInitializeErasureCoding","InvalidBlockSmallSize","InvalidLastArchivedBlock","NewArchivedSegment","Padding","ParentSegmentHeader","Segment","SegmentItem","V0","add_block","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","decode","decode","decode","decode_all","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deserialize","drop","drop","drop","drop","drop","encode_to","encode_to","encode_to","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","hash","init","init","init","init","init","into","into","into","into","into","is_piece_valid","is_record_commitment_hash_valid","last_archived_block_number","new","object_mapping","partial_cmp","pieces","segment_header","serialize","size_hint","size_hint","size_hint","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","with_initial_state","archived_block_bytes","block_bytes","items","bytes","bytes","bytes","DataShardsReconstruction","FailedToInitializeErasureCoding","IncorrectPiecePosition","InvalidInputPieceCommitment","PiecesReconstructor","ReconstructorError","ReconstructorInstantiationError","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","cmp","deref","deref","deref","deref_mut","deref_mut","deref_mut","drop","drop","drop","eq","eq","fmt","fmt","fmt","fmt","fmt","from","from","from","hash","init","init","init","into","into","into","new","partial_cmp","reconstruct_piece","reconstruct_segment","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","DataShardsReconstruction","FailedToInitializeErasureCoding","IncorrectSegmentOrder","ReconstructedContents","Reconstructor","ReconstructorError","ReconstructorInstantiationError","SegmentDecoding","add_segment","blocks","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","cmp","default","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","drop","drop","drop","drop","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","hash","init","init","init","init","into","into","into","into","new","partial_cmp","segment_header","to_owned","to_owned","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","actual_segment_index","expected_segment_index"],"q":[[0,"subspace_archiving"],[3,"subspace_archiving::archiver"],[133,"subspace_archiving::archiver::ArchiverInstantiationError"],[135,"subspace_archiving::archiver::Segment"],[136,"subspace_archiving::archiver::SegmentItem"],[139,"subspace_archiving::piece_reconstructor"],[203,"subspace_archiving::reconstructor"],[286,"subspace_archiving::reconstructor::ReconstructorError"],[288,"alloc::vec"],[289,"subspace_core_primitives::objects"],[290,"core::cmp"],[291,"parity_scale_codec::error"],[292,"core::result"],[293,"parity_scale_codec::codec"],[294,"serde::de"],[295,"parity_scale_codec::codec"],[296,"core::fmt"],[297,"core::fmt"],[298,"subspace_core_primitives::crypto::kzg"],[299,"subspace_core_primitives::pieces"],[300,"subspace_core_primitives::segments"],[301,"subspace_core_primitives::crypto"],[302,"subspace_core_primitives::pieces"],[303,"core::option"],[304,"serde::ser"],[305,"alloc::string"],[306,"core::any"],[307,"subspace_core_primitives"]],"d":["","","","Block archiver for Subspace blockchain.","Archiver instantiation error","Contains full block inside","Continuation of the partial block spilled over into the …","Contains the beginning of the block inside, remainder will …","Failed to initialize erasure coding","Invalid block, its size is smaller than already archived …","Invalid last archived block, its size is the same as …","Newly archived segment as a combination of segment header …","Special dummy enum variant only used as an implementation …","Segment header of the parent","Segment represents a collection of items stored in …","Kinds of items that are contained within a segment","","Adds new block to internal buffer, potentially producing …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Validate witness embedded within a piece produced by …","Validate witness for record commitment hash produced by …","Get last archived block if there was any","Create a new instance with specified record size and …","Mappings for objects stored in corresponding pieces.","","Segment of archived history containing pieces","Segment header","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Create a new instance of the archiver with initial state …","Already archived portion of the block","Full block size","Segment items","Block bytes","Block bytes","Block bytes","Segment size is not bigger than record size","Failed to initialize erasure coding","Incorrect piece position provided.","Commitment of input piece is invalid.","Reconstructor helps to retrieve blocks from archived …","Reconstructor-related instantiation error","Reconstructor-related instantiation error.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","","","Returns the missing piece for a segment using given set of …","Returns all the pieces for a segment using given set of …","","","","","","","","","","","","","","","Error during data shards reconstruction","Failed to initialize erasure coding","Incorrect segment order, each next segment must have …","Data structure that contains information reconstructed …","Reconstructor helps to retrieve blocks from archived …","Reconstructor-related instantiation error","Reconstructor-related instantiation error.","Segment size is not bigger than record size","Given a set of pieces of a segment of the archived history …","Reconstructed encoded blocks with their block numbers","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","","","Segment header stored in a segment","","","","","","","","","","","","","","","","","","","",""],"i":[0,0,0,0,0,8,8,8,9,9,9,0,8,8,0,0,7,1,7,8,6,9,1,7,8,6,9,1,7,8,6,9,1,7,8,6,9,1,9,7,8,6,7,8,6,7,8,6,7,8,6,7,8,6,9,1,7,8,6,9,1,6,7,8,6,9,1,7,8,6,7,8,6,9,7,8,6,9,9,1,7,8,6,9,1,9,7,8,6,9,1,7,8,6,9,1,0,0,1,1,6,9,6,6,6,7,8,6,7,8,6,7,8,6,9,1,9,7,8,6,9,1,7,8,6,9,1,7,8,6,9,1,1,44,44,45,46,47,48,36,35,36,36,0,0,0,35,36,37,35,36,37,35,36,37,35,36,37,35,35,36,37,35,36,37,35,36,37,35,36,35,35,36,36,37,35,36,37,35,35,36,37,35,36,37,37,35,37,37,35,36,37,35,36,35,36,37,35,36,37,35,36,37,42,43,42,0,0,0,0,42,40,41,43,42,41,40,43,42,41,40,43,42,41,40,43,42,41,40,43,41,43,42,41,40,43,42,41,40,43,42,41,40,43,42,41,43,43,42,42,41,40,43,42,41,40,43,43,42,41,40,43,42,41,40,40,43,41,43,42,41,40,43,42,43,42,41,40,43,42,41,40,43,42,41,40,49,49],"f":"`````````````````{{b{f{d}}hj}{{f{l}}}}{ce{}{}}000000000{nn}{A`A`}{ll}{AbAb}{bb}{{ce}Ad{}{}}0000{{AbAb}Af}{c{{Aj{nAh}}}Al}{c{{Aj{A`Ah}}}Al}{c{{Aj{lAh}}}Al}{{{An{d}}}{{Aj{cAh}}}{}}00{{B`{An{d}}}{{Aj{cAh}}}{}}00{{B`c}{{Aj{eAh}}}Al{}}00{Bbc{}}000000000{c{{Aj{l}}}Bd}{BbAd}0000{{nc}Ad{BfBh}}{{A`c}Ad{BfBh}}{{lc}Ad{BfBh}}{{nn}j}{{A`A`}j}{{ll}j}{{AbAb}j}{{nBj}Bl}{{A`Bj}Bl}{{lBj}Bl}{{AbBj}Bl}0{{bBj}Bl}{cc{}}0000{{Abc}AdBn}{{}Bb}0000{ce{}{}}0000{{C`CbCdB`}j}{{C`CfCdChB`}j}{b{{Cl{Cj}}}}{C`{{Aj{bAb}}}}`{{AbAb}{{Cl{Af}}}}``{{lc}AjCn}{nBb}{A`Bb}{lBb}{{c{An{d}}}{{f{d}}}{}}00:::::{cD`{}}{c{{Aj{e}}}{}{}}000000000{cDb{}}0000{{C`Dd{An{d}}h}{{Aj{bAb}}}}`````````````>>>>>>{DfDf}{DhDh}{DjDj}{{ce}Ad{}{}}00{{DfDf}Af}{Bbc{}}00000{BbAd}00{{DfDf}j}{{DhDh}j}{{DfBj}Bl}0{{DhBj}Bl}0{{DjBj}Bl}{cc{}}00{{Dfc}AdBn}{{}Bb}00{ce{}{}}00{C`{{Aj{DjDf}}}}{{DfDf}{{Cl{Af}}}}{{Dj{An{{Cl{Dl}}}}Bb}{{Aj{DlDh}}}}{{Dj{An{{Cl{Dl}}}}}{{Aj{DnDh}}}}444{cD`{}}0{c{{Aj{e}}}{}{}}00000{cDb{}}00````````{{E`{An{{Cl{Dl}}}}}{{Aj{EbEd}}}}`88888888{EfEf}{EdEd}{EbEb}{E`E`}{{ce}Ad{}{}}000{{EfEf}Af}{{}Eb}{Bbc{}}0000000{BbAd}000{{EfEf}j}{{EdEd}j}{{EbEb}j}{{EfBj}Bl}0{{EdBj}Bl}0{{EbBj}Bl}{{E`Bj}Bl}{cc{}}000{{Efc}AdBn}{{}Bb}000{ce{}{}}000{{}{{Aj{E`Ef}}}}{{EfEf}{{Cl{Af}}}}`2222{cD`{}}0{c{{Aj{e}}}{}{}}0000000{cDb{}}000``","c":[],"p":[[5,"Archiver",3],[1,"u8"],[5,"Vec",288],[5,"BlockObjectMapping",289],[1,"bool"],[5,"NewArchivedSegment",3],[6,"Segment",3],[6,"SegmentItem",3],[6,"ArchiverInstantiationError",3],[1,"unit"],[6,"Ordering",290],[5,"Error",291],[6,"Result",292],[10,"Input",293],[1,"slice"],[1,"u32"],[1,"usize"],[10,"Deserializer",294],[10,"Output",293],[10,"Sized",295],[5,"Formatter",296],[8,"Result",296],[10,"Hasher",297],[5,"Kzg",298],[5,"PieceArray",299],[5,"SegmentCommitment",300],[5,"Scalar",301],[5,"RecordWitness",299],[8,"BlockNumber",302],[6,"Option",303],[10,"Serializer",304],[5,"String",305],[5,"TypeId",306],[6,"SegmentHeader",302],[6,"ReconstructorInstantiationError",139],[6,"ReconstructorError",139],[5,"PiecesReconstructor",139],[5,"Piece",299],[5,"ArchivedHistorySegment",300],[5,"Reconstructor",203],[5,"ReconstructedContents",203],[6,"ReconstructorError",203],[6,"ReconstructorInstantiationError",203],[15,"InvalidBlockSmallSize",133],[15,"V0",135],[15,"Block",136],[15,"BlockStart",136],[15,"BlockContinuation",136],[15,"IncorrectSegmentOrder",286]],"b":[[77,"impl-Debug-for-ArchiverInstantiationError"],[78,"impl-Display-for-ArchiverInstantiationError"],[170,"impl-Debug-for-ReconstructorInstantiationError"],[171,"impl-Display-for-ReconstructorInstantiationError"],[172,"impl-Debug-for-ReconstructorError"],[173,"impl-Display-for-ReconstructorError"],[246,"impl-Display-for-ReconstructorInstantiationError"],[247,"impl-Debug-for-ReconstructorInstantiationError"],[248,"impl-Debug-for-ReconstructorError"],[249,"impl-Display-for-ReconstructorError"]]}],\
-["subspace_core_primitives",{"doc":"Core primitives for Subspace Network.","t":"GFSIIIIFPTPFFFTTTTTTTTTFGTTTSPFFFFFFFFFFFSSSFFFFFFFFTTTTTTTTTTTTTTTFIFFGFIFIFPTTTTNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOCNNNNNNNNNNNNNNNNNNNNNNNNNONNOONNONONONNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOFNNNNNNNNNNNNNNNNNNNNNNNTTFNNHHHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNFSFSSFFNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNGFGGFPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOO","n":["ArchivedBlockProgress","ArchivedHistorySegment","BLAKE3_HASH_SIZE","Blake3Hash","BlockHash","BlockNumber","BlockWeight","ChunkWitness","Complete","ERASURE_CODING_RATE","EmptyVec","FlatPieces","HistorySize","LastArchivedBlock","MAX","MAX","MIDDLE","NUM_CHECKPOINTS","NUM_CHUNKS","NUM_CHUNKS","NUM_PIECES","NUM_RAW_RECORDS","NUM_S_BUCKETS","NonEmptyVec","NonEmptyVecErr","ONE","ONE","ONE","PUBLIC_KEY_LENGTH","Partial","Piece","PieceArray","PieceIndex","PieceOffset","PosProof","PosSeed","PotCheckpoints","PotKey","PotOutput","PotSeed","PublicKey","RANDOMNESS_LENGTH","REWARD_SIGNATURE_LENGTH","REWARD_SIGNING_CONTEXT","Randomness","RawRecord","Record","RecordCommitment","RecordWitness","RecordedHistorySegment","RewardSignature","SBucket","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SectorId","SectorIndex","SectorSlotChallenge","SegmentCommitment","SegmentHeader","SegmentIndex","SlotNumber","Solution","SolutionRange","U256","V0","ZERO","ZERO","ZERO","ZERO","add","add","add","add","add","add_assign","add_assign","add_assign","add_assign","archived_progress","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_slice","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","backward_checked","backward_checked","backward_checked","backward_checked","bidirectional_distance","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","checked_add","checked_div","checked_mul","checked_sub","checksum","chunk","chunk_witness","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","commitment","commitment_mut","crypto","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","derive_evaluation_seed","derive_expiration_history_size","derive_global_challenge","derive_global_randomness","derive_piece_index","derive_sector_slot_challenge","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","div","div","div","div","div","div_assign","div_assign","div_assign","div_assign","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","first","first_piece_index","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","forward_checked","forward_checked","forward_checked","forward_checked","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_be_bytes","from_bytes","from_genesis","from_hex","from_hex","from_hex","from_le_bytes","from_str","genesis_solution","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","history_size","in_pieces","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_inner","into_reward_address_format","iter","iter_mut","key","last","last_archived_block","last_piece_index","len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","mul","mul","mul","mul","mul","mul_assign","mul_assign","mul_assign","mul_assign","new","new","new","new","new_boxed","new_boxed","new_boxed","new_boxed","new_with_entry","new_zero_vec","number","objects","one","output","par_parity","par_parity_mut","par_source","par_source_mut","parity","parity_mut","partial","partial_archived","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","piece_offset","position","prev_segment_header_hash","proof_of_space","public_key","push","record","record_commitment","record_mut","record_witness","rem","reward_address","s_bucket_audit_index","saturating_add","saturating_mul","saturating_sub","sector_expiration_check","sector_index","seed","seed_with_entropy","segment_commitment","segment_index","segment_index","segment_index","segment_piece_indexes","segment_piece_indexes_source_first","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","set_complete","set_partial","set_partial_archived","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","slice_from_repr","slice_mut_from_repr","slice_mut_to_repr","slice_to_repr","source","source_mut","split","split_mut","steps_between","steps_between","steps_between","steps_between","sub","sub","sub","sub","sub","sub_assign","sub_assign","sub_assign","sub_assign","to_be_bytes","to_bytes","to_bytes","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_le_bytes","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_vec","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","witness","witness_mut","wrapping_add","wrapping_sub","zero","last_archived_block","prev_segment_header_hash","segment_commitment","segment_index","Blake3Checksummed","borrow","borrow_mut","clone","clone_into","decode","decode_all","decode_all_with_depth_limit","decode_with_depth_limit","deref","deref_mut","drop","encode_to","encoded_size","fmt","from","init","into","size_hint","to_keyed_vec","to_owned","try_from","try_into","type_id","FULL_BYTES","SAFE_BYTES","Scalar","as_mut","as_ref","blake3_254_hash_to_scalar","blake3_hash","blake3_hash_list","blake3_hash_parallel","blake3_hash_with_key","borrow","borrow_mut","clone","clone_into","cmp","decode","decode_all","decode_all_with_depth_limit","decode_with_depth_limit","default","deref","deref","deref_mut","deref_mut","deserialize","drop","encoded_fixed_size","encoded_size","eq","fmt","from","from","from","from","hash","init","into","kzg","max_encoded_len","partial_cmp","serialize","size_hint","slice_from_repr","slice_mut_from_repr","slice_mut_to_repr","slice_option_from_repr","slice_option_mut_from_repr","slice_option_mut_to_repr","slice_option_to_repr","slice_to_repr","to_bytes","to_keyed_vec","to_owned","try_from","try_from","try_from","try_into","type_id","type_info","using_encoded","vec_from_repr","vec_option_from_repr","vec_option_to_repr","vec_to_repr","Commitment","EMBEDDED_KZG_SETTINGS_BYTES","Kzg","NUM_G1_POWERS","NUM_G2_POWERS","Polynomial","Witness","as_mut","as_mut","as_ref","as_ref","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","bytes_to_kzg_settings","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","commit","create_witness","default","default","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","drop","drop","drop","drop","embedded_kzg_settings","eq","eq","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","get_fft_settings","init","init","init","init","into","into","into","into","new","normalize","poly","slice_from_repr","slice_mut_from_repr","slice_mut_to_repr","slice_option_from_repr","slice_option_mut_from_repr","slice_option_mut_to_repr","slice_option_to_repr","slice_to_repr","to_bytes","to_bytes","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from_bytes","try_from_bytes","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vec_from_repr","vec_option_from_repr","vec_option_to_repr","vec_to_repr","verify","BlockObject","BlockObjectMapping","GlobalObject","PieceObject","PieceObjectMapping","V0","V0","V0","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","cmp","decode","decode","decode","decode","decode","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","default","default","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deserialize","deserialize","deserialize","deserialize","deserialize","drop","drop","drop","drop","drop","encode","encode","encode_to","encode_to","encode_to","encode_to","encode_to","eq","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","hash","hash","hash","hash","hash","hash","hash","init","init","init","init","init","into","into","into","into","into","objects","objects","offset","offset","offset","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","piece_index","serialize","serialize","serialize","serialize","serialize","set_offset","size_hint","size_hint","size_hint","size_hint","size_hint","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_owned","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_info","type_info","type_info","type_info","type_info","using_encoded","using_encoded","hash","offset","offset","piece_index","hash","offset"],"q":[[0,"subspace_core_primitives"],[1415,"subspace_core_primitives::SegmentHeader"],[1419,"subspace_core_primitives::checksum"],[1443,"subspace_core_primitives::crypto"],[1507,"subspace_core_primitives::crypto::kzg"],[1626,"subspace_core_primitives::objects"],[1794,"subspace_core_primitives::objects::BlockObject"],[1796,"subspace_core_primitives::objects::GlobalObject"],[1798,"subspace_core_primitives::objects::PieceObject"],[1800,"byte_slice_cast"],[1801,"core::result"],[1802,"byte_slice_cast"],[1803,"core::option"],[1804,"num_traits::ops::wrapping"],[1805,"core::cmp"],[1806,"core::cmp"],[1807,"parity_scale_codec::codec"],[1808,"parity_scale_codec::codec"],[1809,"parity_scale_codec::decode_finished"],[1810,"serde::de"],[1811,"serde::de"],[1812,"core::iter::traits::collect"],[1813,"parity_scale_codec::codec"],[1814,"parity_scale_codec::codec"],[1815,"core::fmt"],[1816,"core::convert"],[1817,"core::hash"],[1818,"core::convert"],[1819,"alloc::boxed"],[1820,"rayon::iter"],[1821,"core::iter::traits::exact_size"],[1822,"serde::ser"],[1823,"serde::ser"],[1824,"core::any"],[1825,"scale_info::ty"],[1826,"core::ops::function"],[1827,"rust_kzg_blst::types::fr"],[1828,"rust_kzg_blst::types::g1"],[1829,"rust_kzg_blst::types::kzg_settings"],[1830,"rust_kzg_blst::types::poly"],[1831,"rust_kzg_blst::types::fft_settings"],[1832,"alloc::sync"]],"d":["Progress of an archived block.","Archived history segment after archiving is applied.","Size of BLAKE3 hash output (in bytes).","BLAKE3 hash output","Block hash in Subspace network.","Block number in Subspace network.","BlockWeight type for fork choice rules.","Witness for chunk contained within a record.","The block has been fully archived.","Erasure coding rate for records during archiving process.","Tried to create with an empty Vec","Flat representation of multiple pieces concatenated for …","Size of blockchain history in segments.","Last archived block","Max s-bucket index","Maximum value.","The middle of the piece distance field. The analogue of …","Number of PoT checkpoints produced (used to optimize …","Number of chunks (scalars) within one raw record.","Number of chunks (scalars) within one record.","Number of pieces in one segment of archived history.","Number of raw records in one segment of recorded history.","Number of s-buckets contained within one record (and by …","A Vec<> that enforces the invariant that it cannot be …","Error codes for NonEmptyVec.","Piece index 1.","Piece index 1.","Segment index 1.","Length of public key in bytes.","Number of partially archived bytes of a block.","A piece of archival history in Subspace Network.","A piece of archival history in Subspace Network.","Piece index in consensus","Piece offset in sector","Proof of space proof bytes.","Proof of space seed.","Proof of time checkpoints, result of proving","Proof of time key(input to the encryption).","Proof of time output, can be intermediate checkpoint or …","Proof of time seed","A Ristretto Schnorr public key as bytes produced by …","Byte length of a randomness type.","Length of signature in bytes","Signing context used for creating reward signatures by …","Type of randomness.","Raw record contained within recorded history segment …","Record contained within a piece.","Record commitment contained within a piece.","Record witness contained within a piece.","Recorded history segment before archiving is applied.","A Ristretto Schnorr signature as bytes produced by …","S-bucket used in consensus","Size in bytes.","Size of raw record in bytes, is guaranteed to be a …","Size of a segment record given the global piece size (in …","Size of record commitment in bytes.","Size of record witness in bytes.","Size of chunk witness in bytes.","Size of a piece (in bytes).","Size of segment commitment in bytes.","Size of recorded history segment in bytes.","Size of archived history segment in bytes.","Size of proof of space seed in bytes.","Size of proof of space proof in bytes.","Size of proof of time key in bytes","Size of proof of time seed in bytes","Size of proof of time proof in bytes","Data structure representing sector ID in farmer’s plot","Sector index in consensus","Challenge used for a particular sector for particular slot","Segment commitment contained within segment header.","Segment header for a specific segment.","Segment index type.","Slot number in Subspace network.","Farmer solution for slot challenge.","Type of solution range.","256-bit unsigned integer","V0 of the segment header data structure","S-bucket 0.","Piece index 0.","Piece index 0.","Segment index 0.","","","","","","","","","","Progress of an archived block.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the slice of the entries.","","","","","","","","","","","","","","","","","","","Bidirectional distance metric implemented on top of …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Adds two numbers, checking for overflow. If overflow …","Divides two numbers, checking for underflow, overflow and …","Multiplies two numbers, checking for underflow or …","Subtracts two numbers, checking for underflow. If …","Module containing wrapper for SCALE encoding/decoding with …","Chunk at above offset","Witness for above chunk","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Commitment contained within a piece.","Mutable commitment contained within a piece.","Various cryptographic utilities used across Subspace …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","We assume a block can always fit into the segment …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Derive evaluation seed","Derive history size when sector created at history_size …","Derive global slot challenge from global randomness.","Derives the global randomness from the output","Derive piece index that should be stored in sector at …","Derive sector slot challenge for this sector from provided …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the first entry.","Get the first piece index in this segment.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","Returns the argument unchanged.","","","Returns the argument unchanged.","","","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","","","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Create from big endian bytes","Create piece index from bytes.","Derive initial PoT seed from genesis block hash","","","","Create from little endian bytes","","Dummy solution for the genesis block","","","","","","","","","","","","","Proof hash.","","","","","Public key hash.","","","","Hash of the whole segment header","","","","","Size of the blockchain history at time of sector creation","Size of blockchain history in pieces.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Extract internal representation.","Transform solution with one reward address type into …","Returns an iterator for the entries.","Returns a mutable iterator for the entries.","Derive key from proof of time seed","Returns the last entry.","Last archived block","Get the last piece index in this segment.","Returns the number of entries.","","","","","","","","","","","","","","","","","","","","","","","","","","","Allocate FlatPieces that will hold piece_count pieces …","Create new instance.","Create new sector ID by deriving it from public key and …","Creates the Vec.","Create boxed value without hitting stack overflow","Create boxed value without hitting stack overflow","Create boxed value without hitting stack overflow","Create boxed value without hitting stack overflow","Creates the Vec with the entry.","Create vector filled with zeroe records without hitting …","Block number","Data structures related to objects (useful data) stored on …","One (multiplicative identity) of this type.","Get proof of time output out of checkpoints (last …","Parallel iterator over parity pieces (odd indices).","Mutable parallel iterator over parity pieces (odd indices).","Parallel iterator over source pieces (even indices).","Mutable parallel iterator over source pieces (even …","Iterator over parity pieces (odd indices).","Mutable iterator over parity pieces (odd indices).","Return the number of partially archived bytes if the …","Returns the number of partially archived bytes for a block.","","","","","","","","","","","","","","","","Pieces offset within sector","Position of a piece in a segment","Hash of the segment header of the previous segment","Proof of space for piece offset","Public key of the farmer that created the solution","Adds an entry to the end.","Record contained within a piece.","Record commitment that can use used to verify that piece …","Mutable record contained within a piece.","Witness for above record commitment","","Address for receiving block reward","Index of s-bucket within sector to be audited","Saturating addition. Computes self + other, saturating at …","Saturating multiplication. Computes self * other, …","Saturating subtraction. Computes self - other, saturating …","History size at which expiration check for sector happens.","Index of the sector where solution was found","Derive seed from proof of time in case entropy injection …","Derive seed from proof of time with entropy injection","Segment commitment of the records in a segment.","Segment index piece index corresponds to","Segment index that corresponds to this history size.","Segment index","List of piece indexes that belong to this segment.","List of piece indexes that belong to this segment with …","","","","","","","","","","","","","","","","","","","","","","","","","","Sets the archived state of this block to …","Sets new number of partially archived bytes.","Sets new number of partially archived bytes.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Convenient conversion from slice of underlying …","Convenient conversion from mutable slice of underlying …","Convenient conversion from mutable slice of record to …","Convenient conversion from slice of record to underlying …","Iterator over source pieces (even indices).","Mutable iterator over source pieces (even indices).","Split piece into underlying components.","Split piece into underlying mutable components.","","","","","","","","","","","","","","Convert to big endian bytes","Convert piece index to bytes.","Convert piece offset to bytes.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Convert to little endian bytes","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the entries in the collection.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Witness contained within a piece.","Mutable witness contained within a piece.","","","Zero (additive identity) of this type.","Last archived block","Hash of the segment header of the previous segment","Root of commitments of all records in a segment.","Segment index","Wrapper data structure that when encoded/decoded will …","","","","","","","","","","","","","","","Returns the argument unchanged.","","Calls U::from(self).","","","","","","","How many bytes Scalar contains physically, use …","How many full bytes can be stored in BLS12-381 scalar (for …","Representation of a single BLS12-381 scalar value.","","","BLAKE3 hashing of a single value truncated to 254 bits.","BLAKE3 hashing of a single value.","BLAKE3 hashing of a list of values.","BLAKE3 hashing of a single value in parallel (only useful …","BLAKE3 keyed hashing of a single value.","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","","","Calls U::from(self).","Tools for KZG commitment scheme","","","","","Convenient conversion from slice of underlying …","Convenient conversion from mutable slice of underlying …","Convenient conversion from mutable slice of scalar to …","Convenient conversion from slice of optional underlying …","Convenient conversion from optional mutable slice of …","Convenient conversion from optional mutable slice of …","Convenient conversion from slice of optional scalar to …","Convenient conversion from slice of scalar to underlying …","Convert scalar into bytes","","","","","","","","","","Convenient conversion from vector of underlying …","Convenient conversion from vector of optional underlying …","Convenient conversion from vector of optional scalar to …","Convenient conversion from vector of scalar to underlying …","Commitment to polynomial","Embedded KZG settings as bytes, too big for no_std in most …","Wrapper data structure for working with KZG commitment …","Number of G1 powers stored in EMBEDDED_KZG_SETTINGS_BYTES","Number of G2 powers stored in EMBEDDED_KZG_SETTINGS_BYTES","Commitment to polynomial","Witness for polynomial evaluation","","","","","","","","","","","","","Function turns bytes into FsKZGSettings, it is up to the …","","","","","","","","","Computes a Commitment to polynomial","Computes a Witness of evaluation of polynomial at index","","","","","","","","","","","","","","","","","","","Embedded KZG settings","","","","","","","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","Get FFT settings for specified number of values, uses …","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Create new instance with given KZG settings.","Normalize polynomial by removing trailing zeroes","Create polynomial from data. Data must be multiple of 32 …","Convenient conversion from slice of underlying …","Convenient conversion from mutable slice of underlying …","Convenient conversion from mutable slice of commitment to …","Convenient conversion from slice of optional underlying …","Convenient conversion from optional mutable slice of …","Convenient conversion from optional mutable slice of …","Convenient conversion from slice of optional commitment to …","Convenient conversion from slice of commitment to …","Convert commitment to raw bytes","Convert witness to raw bytes","","","","","","","","","","","","","","","","","","","","","Try to deserialize commitment from raw bytes","Try to deserialize witness from raw bytes","","","","","","","","","Convenient conversion from vector of underlying …","Convenient conversion from vector of optional underlying …","Convenient conversion from vector of optional commitment …","Convenient conversion from vector of commitment to …","Verifies that value is the evaluation at index of the …","Object stored inside of the block","Mapping of objects stored inside of the block","Object stored inside in the history of the blockchain","Object stored inside of the block","Mapping of objects stored inside of the piece","V0 of object mapping data structure","V0 of object mapping data structure","V0 of object mapping data structure","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Object hash","","","Object hash","","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Objects stored inside of the block","Objects stored inside of the block","Offset of object in the encoded block.","Offset of the object","Offset of the object","","","","","","Piece index where object is contained (at least its …","","","","","","Sets new offset.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Object hash","Offset of object in the encoded block.","Offset of the object","Piece index where object is contained (at least its …","Object hash","Offset of the object"],"i":[0,0,0,0,0,0,0,0,41,19,70,0,0,0,1,5,5,40,9,10,37,19,10,0,0,2,3,4,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,9,10,11,12,13,14,18,19,37,38,39,21,22,23,0,0,0,0,0,0,0,0,0,0,43,1,2,3,4,1,2,3,4,5,1,2,3,4,42,9,10,11,12,13,14,15,17,18,19,20,27,28,29,9,10,11,12,13,14,15,15,17,18,19,20,21,22,23,9,10,11,12,13,14,15,17,18,19,20,9,10,11,12,13,14,15,17,18,19,20,9,10,11,12,13,14,15,15,17,18,19,20,21,22,23,27,28,29,30,9,10,11,12,13,14,15,17,18,19,20,27,28,29,1,2,3,4,0,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,5,5,5,5,0,44,44,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,1,2,3,14,15,17,4,36,27,28,41,42,5,45,29,15,15,0,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,11,12,13,15,4,18,36,37,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,9,10,11,12,13,14,15,17,4,18,19,37,20,39,21,22,23,40,27,41,5,1,2,3,9,9,10,10,11,11,12,12,13,13,14,14,15,15,17,17,4,18,18,36,36,19,19,37,37,20,20,38,38,39,39,21,21,22,22,23,23,40,40,27,27,28,28,41,42,43,44,5,45,45,29,30,70,1,2,3,9,9,10,10,11,11,12,12,13,13,14,14,15,15,17,17,4,18,18,36,36,19,19,37,37,20,38,39,39,21,21,22,22,23,23,40,40,27,28,41,42,43,44,5,45,29,30,70,29,29,20,23,29,29,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,27,28,41,42,43,44,29,1,2,3,4,5,1,2,3,4,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,5,29,30,9,10,11,12,13,14,15,17,18,19,20,27,28,29,9,10,11,12,13,14,15,17,18,19,20,27,28,29,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,30,4,1,1,2,2,3,3,9,10,11,12,13,14,15,17,4,4,18,36,36,19,37,20,38,39,21,21,22,22,23,23,40,27,27,28,41,42,43,44,5,5,45,29,30,70,1,2,3,4,1,1,2,2,3,3,9,10,11,11,11,12,12,12,13,13,13,14,14,15,17,17,4,4,18,18,18,36,36,36,19,37,20,20,38,38,39,39,21,21,22,22,23,23,40,27,27,28,28,41,42,43,44,5,5,5,5,5,5,45,29,30,70,5,2,22,15,17,39,5,21,44,1,2,3,11,12,13,14,15,17,4,18,36,39,22,23,40,27,27,28,41,42,43,43,5,45,29,44,36,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,17,44,30,30,22,30,43,4,30,1,2,3,11,12,13,15,4,18,36,37,20,39,21,22,23,40,1,2,3,4,5,1,2,3,4,17,36,29,30,9,10,15,19,30,10,42,0,5,40,17,17,17,17,17,17,41,42,1,2,3,14,15,17,4,36,27,28,41,42,5,45,29,44,2,43,44,44,30,15,44,15,44,5,44,45,5,5,5,36,44,23,23,43,2,36,43,4,4,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,27,28,41,42,43,44,29,42,41,42,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,10,10,10,10,17,17,15,15,1,2,3,4,1,2,3,4,5,1,2,3,4,5,2,3,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,5,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,1,2,3,4,36,21,22,23,27,5,30,1,1,2,3,9,10,11,11,12,12,13,13,14,14,14,15,17,4,18,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,5,29,30,15,15,5,5,5,109,109,109,109,0,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,95,95,0,95,95,0,0,0,0,0,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,0,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,0,0,0,0,0,0,0,72,73,72,73,99,72,73,100,99,72,73,100,0,99,72,73,100,99,72,73,100,100,100,72,73,99,72,72,73,73,100,99,72,72,73,73,100,99,72,73,100,0,72,73,99,72,73,100,99,99,72,72,73,73,100,100,99,72,73,100,99,72,73,100,100,99,100,72,72,72,72,72,72,72,72,72,73,99,72,73,100,99,72,72,72,72,72,72,72,73,73,73,73,73,73,73,100,72,73,99,72,73,100,99,72,73,100,72,72,72,72,100,0,0,0,0,0,104,106,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,104,105,106,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,104,106,108,104,105,106,107,108,108,104,105,106,107,108,104,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,110,110,111,111,112,112],"f":"``````````````````````````````````````````````````````````````````````````````````{{bb}b}{{dd}d}{{ff}f}{{hh}h}{{jj}j}{{bb}l}{{dd}l}{{ff}l}{{hh}l}`{c{{A`{n}}}{}}0000000000000{Ab{{A`{n}}}}{Ad{{A`{n}}}}{Af{{A`{n}}}}{Ah{{A`{n}}}}{Aj{{A`{n}}}}{Al{{A`{n}}}}{An{{B`{n}}}}{An{{A`{n}}}}{Bb{{A`{n}}}}{Bd{{A`{n}}}}{Bf{{A`{n}}}}{Bh{{A`{n}}}}{Bj{{B`{n}}}}{Bl{{B`{n}}}}{Bn{{B`{n}}}}???????????{c{{Cb{{A`{e}}C`}}}{}Cd}0000000000?>=<;:987654321{Cf{{A`{n}}}}{Ch{{A`{n}}}}{Cj{{A`{n}}}}{{{Cl{c}}}{{A`{c}}}Cn}44444444444444{{bD`}{{Db{b}}}}{{dD`}{{Db{d}}}}{{fD`}{{Db{f}}}}{{hD`}{{Db{h}}}}{{cc}c{DdDf}}{ce{}{}}0000000000000000000000000000000000000000000000000000000000000000000{{jj}{{Db{j}}}}000```{bb}{dd}{ff}{AbAb}{AdAd}{AfAf}{AhAh}{AjAj}{AlAl}{AnAn}{BbBb}{hh}{BdBd}{DhDh}{BfBf}{DjDj}{BhBh}{DlDl}{DnDn}{BjBj}{BlBl}{BnBn}{E`E`}{CfCf}{ChCh}{EbEb}{EdEd}{EfEf}{{{Eh{ce}}}{{Eh{ce}}}CnCn}{jj}{EjEj}{CjCj}{{{Cl{c}}}{{Cl{c}}}Cn}{{ce}l{}{}}00000000000000000000000000000000{{bb}El}{{dd}El}{{ff}El}{{AlAl}El}{{AnAn}El}{{BbBb}El}{{hh}El}{{DhDh}El}{{CfCf}El}{{ChCh}El}{{EbEb}El}{{EdEd}El}{{jj}El}{{EjEj}El}{{CjCj}El}{AnAf}0`{c{{Cb{bEn}}}F`}{c{{Cb{dEn}}}F`}{c{{Cb{fEn}}}F`}{c{{Cb{AfEn}}}F`}{c{{Cb{AhEn}}}F`}{c{{Cb{AjEn}}}F`}{c{{Cb{AlEn}}}F`}{c{{Cb{AnEn}}}F`}{c{{Cb{BbEn}}}F`}{c{{Cb{hEn}}}F`}{c{{Cb{BdEn}}}F`}{c{{Cb{DhEn}}}F`}{c{{Cb{DjEn}}}F`}{c{{Cb{BhEn}}}F`}{c{{Cb{DnEn}}}F`}{c{{Cb{BjEn}}}F`}{c{{Cb{BlEn}}}F`}{c{{Cb{BnEn}}}F`}{c{{Cb{E`En}}}F`}{c{{Cb{CfEn}}}F`}{c{{Cb{ChEn}}}F`}{c{{Cb{EbEn}}}F`}{c{{Cb{EdEn}}}F`}{c{{Cb{EfEn}}}F`}{c{{Cb{{Eh{eg}}En}}}F`FbFb}{c{{Cb{jEn}}}F`}{c{{Cb{CjEn}}}F`}{c{{Cb{{Cl{e}}En}}}F`{}}{{{A`{n}}}{{Cb{cEn}}}{}}000000000000000000000000000{{Fd{A`{n}}}{{Cb{cEn}}}{}}000000000000000000000000000{{c{Ff{b}}}{{Cb{FhEn}}}F`}{{c{Ff{d}}}{{Cb{FhEn}}}F`}{{c{Ff{f}}}{{Cb{FhEn}}}F`}{{c{Ff{Af}}}{{Cb{FhEn}}}F`}{{c{Ff{Ah}}}{{Cb{FhEn}}}F`}{{c{Ff{Aj}}}{{Cb{FhEn}}}F`}{{c{Ff{An}}}{{Cb{FhEn}}}F`}{{c{Ff{h}}}{{Cb{FhEn}}}F`}{{c{Ff{Bd}}}{{Cb{FhEn}}}F`}{{c{Ff{Dh}}}{{Cb{FhEn}}}F`}{{c{Ff{Dj}}}{{Cb{FhEn}}}F`}{{Fdc}{{Cb{eEn}}}F`{}}000000000000000000000000000{{}b}{{}d}{{}f}{{}Ab}{{}Ad}{{}Af}{{}Ah}{{}Aj}{{}Al}{{}An}{{}Bb}{{}h}{{}Bd}{{}Bf}{{}Dj}{{}Bh}{{}Dn}{{}Bj}{{}Bl}{{}Bn}{{}E`}{{}Cf}{{}Eb}{{}j}{D`c{}}000{Abc{}}{Adc{}}2{Afc{}}33{Ahc{}}{Ajc{}}55{Alc{}}{Anc{}}7{Bbc{}}888{Bdc{}}9{Dhc{}}{Bfc{}};;{Djc{}}<{Bhc{}}={Dlc{}}>{Dnc{}}{Bjc{}}{D`c{}}{Blc{}}1{Bnc{}}22{E`c{}}3{Cfc{}}{Chc{}}5555555{Ejc{}}666666{Abc{}}7{Adc{}}88{Afc{}}{Ahc{}}::{Ajc{}}{Alc{}}<{Anc{}}={Bbc{}}>>{Bdc{}}?{Dhc{}}{D`c{}}{Bfc{}}11{Djc{}}222{Dnc{}}{Bjc{}}44{Blc{}}5{Bnc{}}6{E`c{}}77777777777{{CjfDh}Dl}{{CjDhBdDh}{{Db{Dh}}}}{{BhFj}Fl}{BnBh}{{CjfDhFnDh{G`{DhDh}}}d}{{CjFl}Ej}{c{{Cb{b}}}Gb}{c{{Cb{d}}}Gb}{c{{Cb{f}}}Gb}{c{{Cb{Af}}}Gb}{c{{Cb{Ah}}}Gb}{c{{Cb{Aj}}}Gb}{c{{Cb{Al}}}Gb}{c{{Cb{An}}}Gb}{c{{Cb{Bb}}}Gb}{c{{Cb{h}}}Gb}{c{{Cb{Bd}}}Gb}{c{{Cb{Dh}}}Gb}{c{{Cb{Dj}}}Gb}{c{{Cb{Bh}}}Gb}{c{{Cb{Dn}}}Gb}{c{{Cb{Bj}}}Gb}{c{{Cb{Bl}}}Gb}{c{{Cb{Bn}}}Gb}{c{{Cb{Cf}}}Gb}{c{{Cb{Ch}}}Gb}{c{{Cb{Eb}}}Gb}{c{{Cb{Ed}}}Gb}{c{{Cb{Ef}}}Gb}{c{{Cb{{Eh{eg}}}}}GbGdGd}{c{{Cb{Cj}}}Gb}{{bc}b{}}{{dc}d{}}{{fc}f{}}{{hc}h{}}{{jc}j{}}{{bc}l{}}{{dc}l{}}{{fc}l{}}{{hc}l{}}{D`l}000000000000000000000000000000000{b{{Gf{n}}}}{d{{Gf{n}}}}{f{{Gf{n}}}}{Af{{Gf{n}}}}{Ah{{Gf{n}}}}{Aj{{Gf{n}}}}{Al{{Gf{n}}}}{An{{Gf{n}}}}{Bb{{Gf{n}}}}{h{{Gf{n}}}}{Bd{{Gf{n}}}}{Dh{{Gf{n}}}}{Dj{{Gf{n}}}}{Bh{{Gf{n}}}}{Dn{{Gf{n}}}}{Bj{{Gf{n}}}}{Bl{{Gf{n}}}}{Bn{{Gf{n}}}}{E`{{Gf{n}}}}{Cf{{Gf{n}}}}{Ch{{Gf{n}}}}{j{{Gf{n}}}}{Cj{{Gf{n}}}}{{{Cl{c}}}{{Gf{n}}}{}}{ce{}{{Gj{Gh}}}}000000000000000000000000000{{bc}l{GlGn}}{{dc}l{GlGn}}{{fc}l{GlGn}}{{Afc}l{GlGn}}{{Ahc}l{GlGn}}{{Ajc}l{GlGn}}{{Alc}l{GlGn}}{{Anc}l{GlGn}}{{Bbc}l{GlGn}}{{hc}l{GlGn}}{{Bdc}l{GlGn}}{{Dhc}l{GlGn}}{{Djc}l{GlGn}}{{Bhc}l{GlGn}}{{Dnc}l{GlGn}}{{Bjc}l{GlGn}}{{Blc}l{GlGn}}{{Bnc}l{GlGn}}{{E`c}l{GlGn}}{{Cfc}l{GlGn}}{{Chc}l{GlGn}}{{Ebc}l{GlGn}}{{Edc}l{GlGn}}{{Efc}l{GlGn}}{{{Eh{ce}}g}lH`H`{GlGn}}{{jc}l{GlGn}}{{Cjc}l{GlGn}}{{{Cl{c}}e}l{}{GlGn}}{{bb}Hb}{{dd}Hb}{{ff}Hb}{{AbAb}Hb}{{AdAd}Hb}{{AfAf}Hb}{{AhAh}Hb}{{AjAj}Hb}{{AlAl}Hb}{{AnAn}Hb}{{BbBb}Hb}{{hh}Hb}{{BdBd}Hb}{{DhDh}Hb}{{BfBf}Hb}{{DjDj}Hb}{{BhBh}Hb}{{DlDl}Hb}{{DnDn}Hb}{{BjBj}Hb}{{BlBl}Hb}{{BnBn}Hb}{{E`E`}Hb}{{CfCf}Hb}{{ChCh}Hb}{{EbEb}Hb}{{EdEd}Hb}{{EfEf}Hb}{{{Eh{ce}}{Eh{ce}}}HbHdHd}{{jj}Hb}{{EjEj}Hb}{{CjCj}Hb}{{{Cl{c}}{Cl{c}}}HbHd}{{{Cl{c}}}cCn}{hd}{{bHf}Hh}0{{dHf}Hh}0{{fHf}Hh}0{{AbHf}Hh}{{AdHf}Hh}{{AfHf}Hh}{{AhHf}Hh}{{AjHf}Hh}{{AlHf}Hh}{{AnHf}Hh}{{BbHf}Hh}{{hHf}Hh}0{{BdHf}Hh}{{DhHf}Hh}0{{BfHf}Hh}{{DjHf}Hh}{{BhHf}Hh}{{DlHf}Hh}{{DnHf}Hh}{{BjHf}Hh}0{{BlHf}Hh}0{{BnHf}Hh}0{{E`Hf}Hh}{{CfHf}Hh}0{{ChHf}Hh}{{EbHf}Hh}{{EdHf}Hh}{{EfHf}Hh}{{{Eh{ce}}Hf}HhHjHj}{{jHf}Hh}0{{EjHf}Hh}{{CjHf}Hh}{{{Cl{c}}Hf}HhHj}{{HlHf}Hh}{{bD`}{{Db{b}}}}{{dD`}{{Db{d}}}}{{fD`}{{Db{f}}}}{{hD`}{{Db{h}}}}{Fnb}{cc{}}0{Hnd}{Fnf}2222{{{B`{n}}}Af}{I`Af}4{IbAh}{{{B`{n}}}Ah}6{{{B`{n}}}Aj}{IbAj}{AnAl}99{AnBb}::{Hnh};{I`Bd}{{{B`{n}}}Bd}{IdDh}>{hDh}???{{{B`{n}}}Bh}{{{B`{n}}}Dl}{cc{}}0{{{B`{n}}}Dn}{{{B`{n}}}Bj}2{{{B`{n}}}Bl}33{{{B`{n}}}Bn}4{{{B`{n}}}Cf}5{{{B`{n}}}Ch}66666{Fdj}{Fnj}{nj}{Hnj}{Ifj};;;;;{{{B`{n}}}j}{{{B`{n}}}d}{{{A`{n}}{A`{n}}}Bl}{c{{Cb{Ane}}}{{Ih{{A`{n}}}}}{}}{c{{Cb{Bbe}}}{{Ih{{A`{n}}}}}{}}{c{{Cb{Dne}}}{{Ih{{A`{n}}}}}{}}5{Ij{{Cb{Bjc}}}{}}{{ce}{{Eh{ce}}}{}{}}{{bc}lIl}{{dc}lIl}{{fc}lIl}{{Afc}lIl}{{Ahc}lIl}{{Ajc}lIl}{{Alc}lIl}{{Anc}lIl}{{Bbc}lIl}{{hc}lIl}{{Bdc}lIl}{{Dhc}lIl}{DnFl}{{Blc}lIl}{{Bnc}lIl}{{E`c}lIl}{{Cfc}lIl}{CfFl}{{Chc}lIl}{{Ebc}lIl}{{Edc}lIl}{EfFl}{{Efc}lIl}{{jc}lIl}{{Ejc}lIl}{{Cjc}lIl}`{DhId}{{}D`}000000000000000000000000000000000{ce{}{}}000000000000000000000000000000000{Bb{{Gf{An}}}}{{{Eh{ci}}}{{Eh{ce}}}{}{}{{In{e}}}{{In{g}}}}{{{Cl{c}}}{{Jb{J`}}}Cn}0{BlBj}{{{Cl{c}}}cCn}{EfEd}{hd}{{{Cl{c}}}D`Cn}99999999999999999{{bc}b{}}{{dc}d{}}{{fc}f{}}{{hc}h{}}{{jc}j{}}{{bc}l{}}{{dc}l{}}{{fc}l{}}{{hc}l{}}{D`Bb}{IdDh}{{FlJd}Cj}{{{Gf{c}}}{{Cb{{Cl{c}}Hl}}}Cn}{{}{{Jb{Ab}}}}{{}{{Jb{Ad}}}}{{}{{Jb{An}}}}{{}{{Jb{Bf}}}}{c{{Cl{c}}}Cn}{D`{{Gf{Ad}}}}``{{}j}{E`Bn}{Bb{{`{{Jh{}{{Jf{An}}}}}}}}000{Bb{{`{{Jj{}{{Jf{An}}}}}}}}0{Eb{{Db{Fd}}}}{Ed{{Db{Fd}}}}{{bb}{{Db{El}}}}{{dd}{{Db{El}}}}{{ff}{{Db{El}}}}{{AlAl}{{Db{El}}}}{{AnAn}{{Db{El}}}}{{BbBb}{{Db{El}}}}{{hh}{{Db{El}}}}{{DhDh}{{Db{El}}}}{{CfCf}{{Db{El}}}}{{ChCh}{{Db{El}}}}{{EbEb}{{Db{El}}}}{{EdEd}{{Db{El}}}}{{jj}{{Db{El}}}}{{EjEj}{{Db{El}}}}{{CjCj}{{Db{El}}}}`{dFd}{EfFl}``{{{Cl{c}}c}lCn}{AnAd}`0`{{jc}j{}}`{Ejb}{{jj}j}00{{DhDh}{{Db{Dh}}}}`{BnBl}{{BnFl}Bl}{EfBd}{dh}{Dhh}{Efh}{h{{B`{d}}}}0{{bc}CbJl}{{dc}CbJl}{{fc}CbJl}{{Afc}CbJl}{{Ahc}CbJl}{{Ajc}CbJl}{{Alc}CbJl}{{Anc}CbJl}{{Bbc}CbJl}{{hc}CbJl}{{Bdc}CbJl}{{Dhc}CbJl}{{Djc}CbJl}{{Bhc}CbJl}{{Dnc}CbJl}{{Bjc}CbJl}{{Blc}CbJl}{{Bnc}CbJl}{{Cfc}CbJl}{{Chc}CbJl}{{Ebc}CbJl}{{Edc}CbJl}{{Efc}CbJl}{{{Eh{ce}}g}CbJnJnJl}{{Cjc}CbJl}{Edl}{{EbFd}l}{{EdK`}l}{bD`}{dD`}{fD`}{AfD`}{AhD`}{AjD`}{AlD`}{AnD`}{BbD`}{hD`}{BdD`}{DhD`}{DjD`}{BhD`}{DnD`}{BjD`}{BlD`}{BnD`}{E`D`}{CfD`}{ChD`}{EbD`}{EdD`}{EfD`}{{{Eh{ce}}}D`H`H`}{jD`}{CjD`}{{{Cl{c}}}D`{}}{{{A`{{B`{n}}}}}{{A`{Ad}}}}0{{{A`{Ad}}}{{A`{{B`{n}}}}}}0{Bb{{`{{Jj{}{{Jf{An}}}}}}}}0{An{{G`{AdAfAh}}}}0{{bb}{{Db{D`}}}}{{dd}{{Db{D`}}}}{{ff}{{Db{D`}}}}{{hh}{{Db{D`}}}}{{bb}b}{{dd}d}{{ff}f}{{hh}h}{{jj}j}{{bb}l}{{dd}l}{{ff}l}{{hh}l}{j{{B`{n}}}}{d{{B`{n}}}}{f{{B`{n}}}}{{c{A`{n}}}{{Gf{n}}}{}}0000000000000000000000000003{ce{}{}}00000000000000000000000000000000{cKb{}}000000000{{{Cl{c}}}{{Gf{c}}}Cn}{c{{Cb{e}}}{}{}}{D`{{Cb{bc}}}{}}11111{{{A`{n}}}{{Cb{Afc}}}{}}2{{{A`{n}}}{{Cb{Ahc}}}{}}{{{A`{n}}}{{Cb{Ajc}}}{}}44{{{A`{n}}}{{Cb{Alc}}}{}}{{{Gf{n}}}{{Cb{Alc}}}{}}666{{{A`{n}}}{{Cb{Bdc}}}{}}77777777777777777777777777777777777777777777777777777777{cKd{}}000000000000000000000000000000000{{}Kf}00000000000000000000000000{{be}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{de}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{fe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Afe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ahe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Aje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ale}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ane}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bbe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{he}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bde}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Dhe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Dje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bhe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Dne}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ble}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bne}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{E`e}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Cfe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Che}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{je}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Cje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{{Cl{c}}g}e{}{}{{Kj{{A`{n}}}{{Kh{e}}}}}}{AnAh}0{{jj}j}0{{}j}`````{ce{}{}}0{{{Kl{c}}}{{Kl{c}}}Cn}{{ce}l{}{}}{c{{Cb{{Kl{e}}En}}}F`Fb}{{{A`{n}}}{{Cb{cEn}}}{}}{{Fd{A`{n}}}{{Cb{cEn}}}{}}{{Fdc}{{Cb{eEn}}}F`{}}{D`c{}}0{D`l}{{{Kl{c}}e}lH`{GlGn}}{{{Kl{c}}}D`H`}{{{Kl{c}}Hf}HhHj}{cc{}}{{}D`}=3{{c{A`{n}}}{{Gf{n}}}{}}>{c{{Cb{e}}}{}{}}0{cKd{}}```{KnL`}0{{{A`{n}}}Kn}{{{A`{n}}}Fl}{{{A`{{A`{n}}}}}Fl}1{{{B`{n}}{A`{n}}}Fl}{ce{}{}}0{KnKn}{{ce}l{}{}}{{KnKn}El}{c{{Cb{KnEn}}}F`}{{{A`{n}}}{{Cb{cEn}}}{}}{{Fd{A`{n}}}{{Cb{cEn}}}{}}{{Fdc}{{Cb{eEn}}}F`{}}{{}Kn}{D`c{}}{Knc{}}01{c{{Cb{Kn}}}Gb}{D`l}{{}{{Db{D`}}}}{KnD`}{{KnKn}Hb}{{KnHf}Hh}{{{B`{n}}}Kn}{L`Kn}1{cc{}}{{Knc}lIl}{{}D`}{ce{}{}}`1{{KnKn}{{Db{El}}}}{{Knc}CbJl}:{{{A`{L`}}}{{A`{Kn}}}}0{{{A`{Kn}}}{{A`{L`}}}}{{{A`{{Db{L`}}}}}{{A`{{Db{Kn}}}}}}0{{{A`{{Db{Kn}}}}}{{A`{{Db{L`}}}}}}02{Kn{{B`{n}}}}{{c{A`{n}}}{{Gf{n}}}{}}8{c{{Cb{e}}}{}{}}{{{B`{n}}}{{Cb{Knc}}}{}}01{cKd{}}{{}Kf}{{Kne}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{{Gf{L`}}}{{Gf{Kn}}}}{{{Gf{{Db{L`}}}}}{{Gf{{Db{Kn}}}}}}{{{Gf{{Db{Kn}}}}}{{Gf{{Db{L`}}}}}}{{{Gf{Kn}}}{{Gf{L`}}}}```````{I`Lb}{IbLb}10{ce{}{}}0000000{{{A`{n}}D`D`}{{Cb{LdKb}}}}{LfLf}{I`I`}{IbIb}{LhLh}{{ce}l{}{}}000{{LhLf}{{Cb{I`Kb}}}}{{LhLfD`Fd}{{Cb{IbKb}}}}{{}I`}{{}Ib}{D`c{}}{I`c{}}1{Ibc{}}22221202{D`l}000{{}Ld}{{I`I`}Hb}{{IbIb}Hb}{{LfHf}Hh}{{I`Hf}Hh}{{IbHf}Hh}{{LhHf}Hh}{cc{}}{LjLf}{LbI`}22{LbIb}3{{LhD`}{{Cb{{Ln{Ll}}Kb}}}}{{}D`}000{ce{}{}}000{LdLh}{Lfl}{{Lh{A`{Kn}}}{{Cb{LfKb}}}}{{{A`{Lb}}}{{A`{I`}}}}0{{{A`{I`}}}{{A`{Lb}}}}{{{A`{{Db{Lb}}}}}{{A`{{Db{I`}}}}}}0{{{A`{{Db{I`}}}}}{{A`{{Db{Lb}}}}}}02{I`{{B`{n}}}}{Ib{{B`{n}}}}9999{c{{Cb{e}}}{}{}}{Af{{Cb{I`c}}}{}}{{{B`{n}}}{{Cb{I`c}}}{}}{Bd{{Cb{I`c}}}{}}2130{Aj{{Cb{Ibc}}}{}}0{Ah{{Cb{Ibc}}}{}}{{{B`{n}}}{{Cb{Ibc}}}{}}0616{{{B`{n}}}{{Cb{I`Kb}}}}{{{B`{n}}}{{Cb{IbKb}}}}8888{cKd{}}000{{{Gf{Lb}}}{{Gf{I`}}}}{{{Gf{{Db{Lb}}}}}{{Gf{{Db{I`}}}}}}{{{Gf{{Db{I`}}}}}{{Gf{{Db{Lb}}}}}}{{{Gf{I`}}}{{Gf{Lb}}}}{{LhI`D`FdKnIb}Hb}````````{ce{}{}}000000000{M`M`}{MbMb}{MdMd}{MfMf}{MhMh}{{ce}l{}{}}0000{{M`M`}El}{{MbMb}El}{{MdMd}El}{{MfMf}El}{{MhMh}El}{c{{Cb{M`En}}}F`}{c{{Cb{MbEn}}}F`}{c{{Cb{MdEn}}}F`}{c{{Cb{MfEn}}}F`}{c{{Cb{MhEn}}}F`}{{{A`{n}}}{{Cb{cEn}}}{}}0000{{Fd{A`{n}}}{{Cb{cEn}}}{}}0000{{Fdc}{{Cb{eEn}}}F`{}}0000{{}Mb}{{}Mf}{D`c{}}000000000{c{{Cb{M`}}}Gb}{c{{Cb{Mb}}}Gb}{c{{Cb{Md}}}Gb}{c{{Cb{Mf}}}Gb}{c{{Cb{Mh}}}Gb}{D`l}0000{Mb{{Gf{n}}}}{Mf{{Gf{n}}}}{{M`c}l{GlGn}}{{Mbc}l{GlGn}}{{Mdc}l{GlGn}}{{Mfc}l{GlGn}}{{Mhc}l{GlGn}}{{M`M`}Hb}{{MbMb}Hb}{{MdMd}Hb}{{MfMf}Hb}{{MhMh}Hb}{{M`Hf}Hh}{{MbHf}Hh}{{MdHf}Hh}{{MfHf}Hh}{{MhHf}Hh}{cc{}}0000{M`Fl}{{M`c}lIl}{{Mbc}lIl}{MdFl}{{Mdc}lIl}{{Mfc}lIl}{{Mhc}lIl}{{}D`}0000{ce{}{}}0000``{M`Fd}{MdFd}{MhFd}{{M`M`}{{Db{El}}}}{{MbMb}{{Db{El}}}}{{MdMd}{{Db{El}}}}{{MfMf}{{Db{El}}}}{{MhMh}{{Db{El}}}}{Mhd}{{M`c}CbJl}{{Mbc}CbJl}{{Mdc}CbJl}{{Mfc}CbJl}{{Mhc}CbJl}{{M`Fd}l}{M`D`}{MbD`}{MdD`}{MfD`}{MhD`}{{c{A`{n}}}{{Gf{n}}}{}}0000{ce{}{}}0000{c{{Cb{e}}}{}{}}000000000{cKd{}}0000{{}Kf}0000{{Mbe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Mfe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}``````","c":[],"p":[[5,"SBucket",0],[5,"PieceIndex",0],[5,"PieceOffset",0],[5,"SegmentIndex",0],[5,"U256",0],[1,"unit"],[1,"u8"],[1,"slice"],[5,"RawRecord",0],[5,"Record",0],[5,"RecordCommitment",0],[5,"RecordWitness",0],[5,"ChunkWitness",0],[5,"Piece",0],[5,"PieceArray",0],[1,"array"],[5,"FlatPieces",0],[5,"SegmentCommitment",0],[5,"RecordedHistorySegment",0],[5,"Randomness",0],[5,"PotKey",0],[5,"PotSeed",0],[5,"PotOutput",0],[6,"Error",1800],[6,"Result",1801],[10,"FromByteSlice",1800],[5,"PublicKey",0],[5,"RewardSignature",0],[5,"SectorId",0],[5,"NonEmptyVec",0],[10,"Clone",1802],[1,"usize"],[6,"Option",1803],[10,"WrappingSub",1804],[10,"Ord",1805],[5,"HistorySize",0],[5,"ArchivedHistorySegment",0],[5,"PosSeed",0],[5,"PosProof",0],[5,"PotCheckpoints",0],[6,"ArchivedBlockProgress",0],[5,"LastArchivedBlock",0],[6,"SegmentHeader",0],[5,"Solution",0],[5,"SectorSlotChallenge",0],[6,"Ordering",1805],[5,"Error",1806],[10,"Input",1807],[10,"Decode",1807],[1,"u32"],[20,"MaybeUninit",1808],[5,"DecodeFinished",1809],[8,"SlotNumber",0],[8,"Blake3Hash",0],[1,"u16"],[1,"tuple"],[10,"Deserializer",1810],[10,"Deserialize",1810],[5,"Vec",1811],[1,"char"],[10,"FromIterator",1812],[10,"Output",1807],[10,"Sized",1813],[10,"Encode",1807],[1,"bool"],[10,"PartialEq",1805],[5,"Formatter",1814],[8,"Result",1814],[10,"Debug",1814],[6,"NonEmptyVecErr",0],[1,"u64"],[5,"Commitment",1507],[5,"Witness",1507],[5,"NonZeroU64",1815],[1,"u128"],[10,"AsRef",1816],[1,"str"],[10,"Hasher",1817],[10,"Into",1816],[10,"Iterator",1818],[5,"Box",1819],[8,"SectorIndex",0],[17,"Item"],[10,"IndexedParallelIterator",1820],[10,"ExactSizeIterator",1821],[10,"Serializer",1822],[10,"Serialize",1822],[8,"BlockNumber",0],[5,"String",1823],[5,"TypeId",1824],[5,"Type",1825],[17,"Output"],[10,"FnOnce",1826],[5,"Blake3Checksummed",1419],[5,"Scalar",1443],[5,"FsFr",1827],[5,"FsG1",1828],[5,"FsKZGSettings",1829],[5,"Polynomial",1507],[5,"Kzg",1507],[5,"FsPoly",1830],[5,"FsFFTSettings",1831],[5,"Arc",1832],[6,"BlockObject",1626],[5,"BlockObjectMapping",1626],[6,"PieceObject",1626],[5,"PieceObjectMapping",1626],[6,"GlobalObject",1626],[15,"V0",1415],[15,"V0",1794],[15,"V0",1796],[15,"V0",1798]],"b":[[112,"impl-AsMut%3C%5Bu8;+Piece::SIZE%5D%3E-for-PieceArray"],[113,"impl-AsMut%3C%5Bu8%5D%3E-for-PieceArray"],[149,"impl-AsRef%3C%5Bu8;+Piece::SIZE%5D%3E-for-PieceArray"],[150,"impl-AsRef%3C%5Bu8%5D%3E-for-PieceArray"],[783,"impl-Display-for-SBucket"],[784,"impl-Debug-for-SBucket"],[785,"impl-Debug-for-PieceIndex"],[786,"impl-Display-for-PieceIndex"],[787,"impl-Display-for-PieceOffset"],[788,"impl-Debug-for-PieceOffset"],[797,"impl-Debug-for-SegmentIndex"],[798,"impl-Display-for-SegmentIndex"],[800,"impl-Display-for-HistorySize"],[801,"impl-Debug-for-HistorySize"],[807,"impl-Debug-for-PotKey"],[808,"impl-Display-for-PotKey"],[809,"impl-Debug-for-PotSeed"],[810,"impl-Display-for-PotSeed"],[811,"impl-Display-for-PotOutput"],[812,"impl-Debug-for-PotOutput"],[814,"impl-Debug-for-PublicKey"],[815,"impl-Display-for-PublicKey"],[821,"impl-Debug-for-U256"],[822,"impl-Display-for-U256"],[840,"impl-From%3C%5Bu8;+RecordCommitment::SIZE%5D%3E-for-RecordCommitment"],[841,"impl-From%3CCommitment%3E-for-RecordCommitment"],[843,"impl-From%3CWitness%3E-for-RecordWitness"],[844,"impl-From%3C%5Bu8;+RecordWitness::SIZE%5D%3E-for-RecordWitness"],[846,"impl-From%3C%5Bu8;+ChunkWitness::SIZE%5D%3E-for-ChunkWitness"],[847,"impl-From%3CWitness%3E-for-ChunkWitness"],[856,"impl-From%3CCommitment%3E-for-SegmentCommitment"],[857,"impl-From%3C%5Bu8;+SegmentCommitment::SIZE%5D%3E-for-SegmentCommitment"],[858,"impl-From%3CNonZeroU64%3E-for-HistorySize"],[860,"impl-From%3CSegmentIndex%3E-for-HistorySize"],[884,"impl-From%3Cu32%3E-for-U256"],[885,"impl-From%3Cu16%3E-for-U256"],[886,"impl-From%3Cu8%3E-for-U256"],[887,"impl-From%3Cu64%3E-for-U256"],[888,"impl-From%3Cu128%3E-for-U256"],[919,"impl-Hash-for-PublicKey"],[920,"impl-PublicKey"],[924,"impl-SegmentHeader"],[925,"impl-Hash-for-SegmentHeader"],[1263,"impl-TryFrom%3C%26%5Bu8%5D%3E-for-Piece"],[1264,"impl-TryFrom%3CVec%3Cu8%3E%3E-for-Piece"],[1473,"impl-From%3C%5Bu8;+Self::SAFE_BYTES%5D%3E-for-Scalar"],[1474,"impl-From%3CFsFr%3E-for-Scalar"],[1475,"impl-From%3C%26%5Bu8;+Self::SAFE_BYTES%5D%3E-for-Scalar"],[1497,"impl-TryFrom%3C%26%5Bu8;+Self::FULL_BYTES%5D%3E-for-Scalar"],[1498,"impl-TryFrom%3C%5Bu8;+Self::FULL_BYTES%5D%3E-for-Scalar"],[1596,"impl-TryFrom%3C%26RecordCommitment%3E-for-Commitment"],[1597,"impl-TryFrom%3C%5Bu8;+Self::SIZE%5D%3E-for-Commitment"],[1598,"impl-TryFrom%3C%26SegmentCommitment%3E-for-Commitment"],[1599,"impl-TryFrom%3CRecordCommitment%3E-for-Commitment"],[1600,"impl-TryFrom%3C%26%5Bu8;+Self::SIZE%5D%3E-for-Commitment"],[1602,"impl-TryFrom%3CSegmentCommitment%3E-for-Commitment"],[1603,"impl-TryFrom%3CChunkWitness%3E-for-Witness"],[1604,"impl-TryFrom%3C%26ChunkWitness%3E-for-Witness"],[1605,"impl-TryFrom%3C%26RecordWitness%3E-for-Witness"],[1606,"impl-TryFrom%3C%26%5Bu8;+Self::SIZE%5D%3E-for-Witness"],[1607,"impl-TryFrom%3C%5Bu8;+Self::SIZE%5D%3E-for-Witness"],[1609,"impl-TryFrom%3CRecordWitness%3E-for-Witness"],[1723,"impl-BlockObject"],[1724,"impl-Hash-for-BlockObject"],[1726,"impl-PieceObject"],[1727,"impl-Hash-for-PieceObject"]]}],\
+["subspace_core_primitives",{"doc":"Core primitives for Subspace Network.","t":"GFSIIIIFPTPFFFTTTTTTTTTFGTTTSPFFFFFFFFFFFSSSFFFFFFFFTTTTTTTTTTTTTTTFIFFGFIFIFPTTTTNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOCNNNNNNNNNNNNNNNNNNNNNNNNNONNOONNONONONNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOFNNNNNNNNNNNNNNNNNNNNNNNTTFNNHHHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNFSFSSFFNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNGFGGFPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOO","n":["ArchivedBlockProgress","ArchivedHistorySegment","BLAKE3_HASH_SIZE","Blake3Hash","BlockHash","BlockNumber","BlockWeight","ChunkWitness","Complete","ERASURE_CODING_RATE","EmptyVec","FlatPieces","HistorySize","LastArchivedBlock","MAX","MAX","MIDDLE","NUM_CHECKPOINTS","NUM_CHUNKS","NUM_CHUNKS","NUM_PIECES","NUM_RAW_RECORDS","NUM_S_BUCKETS","NonEmptyVec","NonEmptyVecErr","ONE","ONE","ONE","PUBLIC_KEY_LENGTH","Partial","Piece","PieceArray","PieceIndex","PieceOffset","PosProof","PosSeed","PotCheckpoints","PotKey","PotOutput","PotSeed","PublicKey","RANDOMNESS_LENGTH","REWARD_SIGNATURE_LENGTH","REWARD_SIGNING_CONTEXT","Randomness","RawRecord","Record","RecordCommitment","RecordWitness","RecordedHistorySegment","RewardSignature","SBucket","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SectorId","SectorIndex","SectorSlotChallenge","SegmentCommitment","SegmentHeader","SegmentIndex","SlotNumber","Solution","SolutionRange","U256","V0","ZERO","ZERO","ZERO","ZERO","add","add","add","add","add","add_assign","add_assign","add_assign","add_assign","archived_progress","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_slice","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","backward_checked","backward_checked","backward_checked","backward_checked","bidirectional_distance","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","checked_add","checked_div","checked_mul","checked_sub","checked_sub","checksum","chunk","chunk_witness","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","commitment","commitment_mut","crypto","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","derive_evaluation_seed","derive_expiration_history_size","derive_global_challenge","derive_global_randomness","derive_piece_index","derive_sector_slot_challenge","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","div","div","div","div","div","div_assign","div_assign","div_assign","div_assign","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","first","first_piece_index","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","forward_checked","forward_checked","forward_checked","forward_checked","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_be_bytes","from_bytes","from_genesis","from_hex","from_hex","from_hex","from_le_bytes","from_str","genesis_solution","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","history_size","in_pieces","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_inner","into_reward_address_format","iter","iter_mut","key","last","last_archived_block","last_piece_index","len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","mul","mul","mul","mul","mul","mul_assign","mul_assign","mul_assign","mul_assign","new","new","new","new","new","new_boxed","new_boxed","new_boxed","new_boxed","new_with_entry","new_zero_vec","number","objects","one","output","par_parity","par_parity_mut","par_source","par_source_mut","parity","parity_mut","partial","partial_archived","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","piece_offset","position","prev_segment_header_hash","proof_of_space","public_key","push","record","record_commitment","record_mut","record_witness","rem","reward_address","s_bucket_audit_index","saturating_add","saturating_mul","saturating_sub","sector_expiration_check","sector_index","seed","seed_with_entropy","segment_commitment","segment_index","segment_index","segment_index","segment_piece_indexes","segment_piece_indexes_source_first","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","set_complete","set_partial","set_partial_archived","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","slice_from_repr","slice_mut_from_repr","slice_mut_to_repr","slice_to_repr","source","source_mut","split","split_mut","steps_between","steps_between","steps_between","steps_between","sub","sub","sub","sub","sub","sub_assign","sub_assign","sub_assign","sub_assign","to_be_bytes","to_bytes","to_bytes","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_le_bytes","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_vec","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","witness","witness_mut","wrapping_add","wrapping_sub","zero","last_archived_block","prev_segment_header_hash","segment_commitment","segment_index","Blake3Checksummed","borrow","borrow_mut","clone","clone_into","decode","decode_all","decode_all_with_depth_limit","decode_with_depth_limit","deref","deref_mut","drop","encode_to","encoded_size","fmt","from","init","into","size_hint","to_keyed_vec","to_owned","try_from","try_into","type_id","FULL_BYTES","SAFE_BYTES","Scalar","as_mut","as_ref","blake3_254_hash_to_scalar","blake3_hash","blake3_hash_list","blake3_hash_parallel","blake3_hash_with_key","borrow","borrow_mut","clone","clone_into","cmp","decode","decode_all","decode_all_with_depth_limit","decode_with_depth_limit","default","deref","deref","deref_mut","deref_mut","deserialize","drop","encoded_fixed_size","encoded_size","eq","fmt","from","from","from","from","hash","init","into","kzg","max_encoded_len","partial_cmp","serialize","size_hint","slice_from_repr","slice_mut_from_repr","slice_mut_to_repr","slice_option_from_repr","slice_option_mut_from_repr","slice_option_mut_to_repr","slice_option_to_repr","slice_to_repr","to_bytes","to_keyed_vec","to_owned","try_from","try_from","try_from","try_into","type_id","type_info","using_encoded","vec_from_repr","vec_option_from_repr","vec_option_to_repr","vec_to_repr","Commitment","EMBEDDED_KZG_SETTINGS_BYTES","Kzg","NUM_G1_POWERS","NUM_G2_POWERS","Polynomial","Witness","as_mut","as_mut","as_ref","as_ref","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","bytes_to_kzg_settings","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","commit","create_witness","default","default","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","drop","drop","drop","drop","embedded_kzg_settings","eq","eq","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","get_fft_settings","init","init","init","init","into","into","into","into","new","normalize","poly","slice_from_repr","slice_mut_from_repr","slice_mut_to_repr","slice_option_from_repr","slice_option_mut_from_repr","slice_option_mut_to_repr","slice_option_to_repr","slice_to_repr","to_bytes","to_bytes","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from_bytes","try_from_bytes","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vec_from_repr","vec_option_from_repr","vec_option_to_repr","vec_to_repr","verify","BlockObject","BlockObjectMapping","GlobalObject","PieceObject","PieceObjectMapping","V0","V0","V0","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","cmp","decode","decode","decode","decode","decode","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","default","default","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deserialize","deserialize","deserialize","deserialize","deserialize","drop","drop","drop","drop","drop","encode","encode","encode_to","encode_to","encode_to","encode_to","encode_to","eq","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","hash","hash","hash","hash","hash","hash","hash","init","init","init","init","init","into","into","into","into","into","objects","objects","offset","offset","offset","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","piece_index","serialize","serialize","serialize","serialize","serialize","set_offset","size_hint","size_hint","size_hint","size_hint","size_hint","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_owned","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_info","type_info","type_info","type_info","type_info","using_encoded","using_encoded","hash","offset","offset","piece_index","hash","offset"],"q":[[0,"subspace_core_primitives"],[1417,"subspace_core_primitives::SegmentHeader"],[1421,"subspace_core_primitives::checksum"],[1445,"subspace_core_primitives::crypto"],[1509,"subspace_core_primitives::crypto::kzg"],[1628,"subspace_core_primitives::objects"],[1796,"subspace_core_primitives::objects::BlockObject"],[1798,"subspace_core_primitives::objects::GlobalObject"],[1800,"subspace_core_primitives::objects::PieceObject"],[1802,"byte_slice_cast"],[1803,"core::result"],[1804,"byte_slice_cast"],[1805,"core::option"],[1806,"num_traits::ops::wrapping"],[1807,"core::cmp"],[1808,"core::cmp"],[1809,"parity_scale_codec::codec"],[1810,"parity_scale_codec::codec"],[1811,"parity_scale_codec::decode_finished"],[1812,"serde::de"],[1813,"serde::de"],[1814,"core::iter::traits::collect"],[1815,"parity_scale_codec::codec"],[1816,"parity_scale_codec::codec"],[1817,"core::fmt"],[1818,"core::convert"],[1819,"core::hash"],[1820,"core::convert"],[1821,"alloc::boxed"],[1822,"rayon::iter"],[1823,"core::iter::traits::exact_size"],[1824,"serde::ser"],[1825,"serde::ser"],[1826,"core::any"],[1827,"scale_info::ty"],[1828,"core::ops::function"],[1829,"rust_kzg_blst::types::fr"],[1830,"rust_kzg_blst::types::g1"],[1831,"rust_kzg_blst::types::kzg_settings"],[1832,"rust_kzg_blst::types::poly"],[1833,"rust_kzg_blst::types::fft_settings"],[1834,"alloc::sync"]],"d":["Progress of an archived block.","Archived history segment after archiving is applied.","Size of BLAKE3 hash output (in bytes).","BLAKE3 hash output","Block hash in Subspace network.","Block number in Subspace network.","BlockWeight type for fork choice rules.","Witness for chunk contained within a record.","The block has been fully archived.","Erasure coding rate for records during archiving process.","Tried to create with an empty Vec","Flat representation of multiple pieces concatenated for …","Size of blockchain history in segments.","Last archived block","Max s-bucket index","Maximum value.","The middle of the piece distance field. The analogue of …","Number of PoT checkpoints produced (used to optimize …","Number of chunks (scalars) within one raw record.","Number of chunks (scalars) within one record.","Number of pieces in one segment of archived history.","Number of raw records in one segment of recorded history.","Number of s-buckets contained within one record (and by …","A Vec<> that enforces the invariant that it cannot be …","Error codes for NonEmptyVec.","Piece index 1.","Piece index 1.","Segment index 1.","Length of public key in bytes.","Number of partially archived bytes of a block.","A piece of archival history in Subspace Network.","A piece of archival history in Subspace Network.","Piece index in consensus","Piece offset in sector","Proof of space proof bytes.","Proof of space seed.","Proof of time checkpoints, result of proving","Proof of time key(input to the encryption).","Proof of time output, can be intermediate checkpoint or …","Proof of time seed","A Ristretto Schnorr public key as bytes produced by …","Byte length of a randomness type.","Length of signature in bytes","Signing context used for creating reward signatures by …","Type of randomness.","Raw record contained within recorded history segment …","Record contained within a piece.","Record commitment contained within a piece.","Record witness contained within a piece.","Recorded history segment before archiving is applied.","A Ristretto Schnorr signature as bytes produced by …","S-bucket used in consensus","Size in bytes.","Size of raw record in bytes, is guaranteed to be a …","Size of a segment record given the global piece size (in …","Size of record commitment in bytes.","Size of record witness in bytes.","Size of chunk witness in bytes.","Size of a piece (in bytes).","Size of segment commitment in bytes.","Size of recorded history segment in bytes.","Size of archived history segment in bytes.","Size of proof of space seed in bytes.","Size of proof of space proof in bytes.","Size of proof of time key in bytes","Size of proof of time seed in bytes","Size of proof of time proof in bytes","Data structure representing sector ID in farmer’s plot","Sector index in consensus","Challenge used for a particular sector for particular slot","Segment commitment contained within segment header.","Segment header for a specific segment.","Segment index type.","Slot number in Subspace network.","Farmer solution for slot challenge.","Type of solution range.","256-bit unsigned integer","V0 of the segment header data structure","S-bucket 0.","Piece index 0.","Piece index 0.","Segment index 0.","","","","","","","","","","Progress of an archived block.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the slice of the entries.","","","","","","","","","","","","","","","","","","","Bidirectional distance metric implemented on top of …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Adds two numbers, checking for overflow. If overflow …","Divides two numbers, checking for underflow, overflow and …","Multiplies two numbers, checking for underflow or …","Checked integer subtraction. Computes self - rhs, …","Subtracts two numbers, checking for underflow. If …","Module containing wrapper for SCALE encoding/decoding with …","Chunk at above offset","Witness for above chunk","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Commitment contained within a piece.","Mutable commitment contained within a piece.","Various cryptographic utilities used across Subspace …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","We assume a block can always fit into the segment …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Derive evaluation seed","Derive history size when sector created at history_size …","Derive global slot challenge from global randomness.","Derives the global randomness from the output","Derive piece index that should be stored in sector at …","Derive sector slot challenge for this sector from provided …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the first entry.","Get the first piece index in this segment.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","Returns the argument unchanged.","","","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","","","","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Create from big endian bytes","Create piece index from bytes.","Derive initial PoT seed from genesis block hash","","","","Create from little endian bytes","","Dummy solution for the genesis block","","","","","","","","","","","","","Proof hash.","","","","","Public key hash.","","","","Hash of the whole segment header","","","","","Size of the blockchain history at time of sector creation","Size of blockchain history in pieces.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Extract internal representation.","Transform solution with one reward address type into …","Returns an iterator for the entries.","Returns a mutable iterator for the entries.","Derive key from proof of time seed","Returns the last entry.","Last archived block","Get the last piece index in this segment.","Returns the number of entries.","","","","","","","","","","","","","","","","","","","","","","","","","","","Allocate FlatPieces that will hold piece_count pieces …","Create new instance","Create new instance.","Create new sector ID by deriving it from public key and …","Creates the Vec.","Create boxed value without hitting stack overflow","Create boxed value without hitting stack overflow","Create boxed value without hitting stack overflow","Create boxed value without hitting stack overflow","Creates the Vec with the entry.","Create vector filled with zeroe records without hitting …","Block number","Data structures related to objects (useful data) stored on …","One (multiplicative identity) of this type.","Get proof of time output out of checkpoints (last …","Parallel iterator over parity pieces (odd indices).","Mutable parallel iterator over parity pieces (odd indices).","Parallel iterator over source pieces (even indices).","Mutable parallel iterator over source pieces (even …","Iterator over parity pieces (odd indices).","Mutable iterator over parity pieces (odd indices).","Return the number of partially archived bytes if the …","Returns the number of partially archived bytes for a block.","","","","","","","","","","","","","","","","Pieces offset within sector","Position of a piece in a segment","Hash of the segment header of the previous segment","Proof of space for piece offset","Public key of the farmer that created the solution","Adds an entry to the end.","Record contained within a piece.","Record commitment that can use used to verify that piece …","Mutable record contained within a piece.","Witness for above record commitment","","Address for receiving block reward","Index of s-bucket within sector to be audited","Saturating addition. Computes self + other, saturating at …","Saturating multiplication. Computes self * other, …","Saturating subtraction. Computes self - other, saturating …","History size at which expiration check for sector happens.","Index of the sector where solution was found","Derive seed from proof of time in case entropy injection …","Derive seed from proof of time with entropy injection","Segment commitment of the records in a segment.","Segment index piece index corresponds to","Segment index that corresponds to this history size.","Segment index","List of piece indexes that belong to this segment.","List of piece indexes that belong to this segment with …","","","","","","","","","","","","","","","","","","","","","","","","","","Sets the archived state of this block to …","Sets new number of partially archived bytes.","Sets new number of partially archived bytes.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Convenient conversion from slice of underlying …","Convenient conversion from mutable slice of underlying …","Convenient conversion from mutable slice of record to …","Convenient conversion from slice of record to underlying …","Iterator over source pieces (even indices).","Mutable iterator over source pieces (even indices).","Split piece into underlying components.","Split piece into underlying mutable components.","","","","","","","","","","","","","","Convert to big endian bytes","Convert piece index to bytes.","Convert piece offset to bytes.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Convert to little endian bytes","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the entries in the collection.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Witness contained within a piece.","Mutable witness contained within a piece.","","","Zero (additive identity) of this type.","Last archived block","Hash of the segment header of the previous segment","Root of commitments of all records in a segment.","Segment index","Wrapper data structure that when encoded/decoded will …","","","","","","","","","","","","","","","Returns the argument unchanged.","","Calls U::from(self).","","","","","","","How many bytes Scalar contains physically, use …","How many full bytes can be stored in BLS12-381 scalar (for …","Representation of a single BLS12-381 scalar value.","","","BLAKE3 hashing of a single value truncated to 254 bits.","BLAKE3 hashing of a single value.","BLAKE3 hashing of a list of values.","BLAKE3 hashing of a single value in parallel (only useful …","BLAKE3 keyed hashing of a single value.","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","","","","Calls U::from(self).","Tools for KZG commitment scheme","","","","","Convenient conversion from slice of underlying …","Convenient conversion from mutable slice of underlying …","Convenient conversion from mutable slice of scalar to …","Convenient conversion from slice of optional underlying …","Convenient conversion from optional mutable slice of …","Convenient conversion from optional mutable slice of …","Convenient conversion from slice of optional scalar to …","Convenient conversion from slice of scalar to underlying …","Convert scalar into bytes","","","","","","","","","","Convenient conversion from vector of underlying …","Convenient conversion from vector of optional underlying …","Convenient conversion from vector of optional scalar to …","Convenient conversion from vector of scalar to underlying …","Commitment to polynomial","Embedded KZG settings as bytes, too big for no_std in most …","Wrapper data structure for working with KZG commitment …","Number of G1 powers stored in EMBEDDED_KZG_SETTINGS_BYTES","Number of G2 powers stored in EMBEDDED_KZG_SETTINGS_BYTES","Commitment to polynomial","Witness for polynomial evaluation","","","","","","","","","","","","","Function turns bytes into FsKZGSettings, it is up to the …","","","","","","","","","Computes a Commitment to polynomial","Computes a Witness of evaluation of polynomial at index","","","","","","","","","","","","","","","","","","","Embedded KZG settings","","","","","","","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","Get FFT settings for specified number of values, uses …","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Create new instance with given KZG settings.","Normalize polynomial by removing trailing zeroes","Create polynomial from data. Data must be multiple of 32 …","Convenient conversion from slice of underlying …","Convenient conversion from mutable slice of underlying …","Convenient conversion from mutable slice of commitment to …","Convenient conversion from slice of optional underlying …","Convenient conversion from optional mutable slice of …","Convenient conversion from optional mutable slice of …","Convenient conversion from slice of optional commitment to …","Convenient conversion from slice of commitment to …","Convert commitment to raw bytes","Convert witness to raw bytes","","","","","","","","","","","","","","","","","","","","","Try to deserialize commitment from raw bytes","Try to deserialize witness from raw bytes","","","","","","","","","Convenient conversion from vector of underlying …","Convenient conversion from vector of optional underlying …","Convenient conversion from vector of optional commitment …","Convenient conversion from vector of commitment to …","Verifies that value is the evaluation at index of the …","Object stored inside of the block","Mapping of objects stored inside of the block","Object stored inside in the history of the blockchain","Object stored inside of the block","Mapping of objects stored inside of the piece","V0 of object mapping data structure","V0 of object mapping data structure","V0 of object mapping data structure","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","Object hash","","","Object hash","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Objects stored inside of the block","Objects stored inside of the block","Offset of object in the encoded block.","Offset of the object","Offset of the object","","","","","","Piece index where object is contained (at least its …","","","","","","Sets new offset.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Object hash","Offset of object in the encoded block.","Offset of the object","Piece index where object is contained (at least its …","Object hash","Offset of the object"],"i":[0,0,0,0,0,0,0,0,41,19,70,0,0,0,1,5,5,40,9,10,37,19,10,0,0,2,3,4,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,9,10,11,12,13,14,18,19,37,38,39,21,22,23,0,0,0,0,0,0,0,0,0,0,43,1,2,3,4,1,2,3,4,5,1,2,3,4,42,9,10,11,12,13,14,15,17,18,19,20,27,28,29,9,10,11,12,13,14,15,15,17,18,19,20,21,22,23,9,10,11,12,13,14,15,17,18,19,20,9,10,11,12,13,14,15,17,18,19,20,9,10,11,12,13,14,15,15,17,18,19,20,21,22,23,27,28,29,30,9,10,11,12,13,14,15,17,18,19,20,27,28,29,1,2,3,4,0,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,5,5,5,4,5,0,44,44,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,1,2,3,14,15,17,4,36,27,28,41,42,5,45,29,15,15,0,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,11,12,13,15,4,18,36,37,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,9,10,11,12,13,14,15,17,4,18,19,37,20,39,21,22,23,40,27,41,5,1,2,3,9,9,10,10,11,11,12,12,13,13,14,14,15,15,17,17,4,18,18,36,36,19,19,37,37,20,20,38,38,39,39,21,21,22,22,23,23,40,40,27,27,28,28,41,42,43,44,5,45,45,29,30,70,1,2,3,9,9,10,10,11,11,12,12,13,13,14,14,15,15,17,17,4,18,18,36,36,19,19,37,37,20,38,39,39,21,21,22,22,23,23,40,40,27,28,41,42,43,44,5,45,29,30,70,29,29,20,23,29,29,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,27,28,41,42,43,44,29,1,2,3,4,5,1,2,3,4,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,5,29,30,9,10,11,12,13,14,15,17,18,19,20,27,28,29,9,10,11,12,13,14,15,17,18,19,20,27,28,29,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,30,4,1,1,2,2,3,3,9,10,11,12,13,14,15,17,4,4,18,36,36,19,37,20,38,39,21,21,22,22,23,23,40,27,27,28,41,42,43,44,5,5,45,29,30,70,1,2,3,4,1,1,2,2,3,3,9,10,11,11,11,12,12,12,13,13,13,14,14,15,17,17,4,4,18,18,18,36,36,36,19,37,20,20,38,38,39,39,21,21,22,22,23,23,40,27,27,28,28,41,42,43,44,5,5,5,5,5,5,45,29,30,70,5,2,22,15,17,39,5,21,44,1,2,3,11,12,13,14,15,17,4,18,36,39,22,23,40,27,27,28,41,42,43,43,5,45,29,44,36,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,17,44,30,30,22,30,43,4,30,1,2,3,11,12,13,15,4,18,36,37,20,39,21,22,23,40,1,2,3,4,5,1,2,3,4,17,4,36,29,30,9,10,15,19,30,10,42,0,5,40,17,17,17,17,17,17,41,42,1,2,3,14,15,17,4,36,27,28,41,42,5,45,29,44,2,43,44,44,30,15,44,15,44,5,44,45,5,5,5,36,44,23,23,43,2,36,43,4,4,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,27,28,41,42,43,44,29,42,41,42,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,10,10,10,10,17,17,15,15,1,2,3,4,1,2,3,4,5,1,2,3,4,5,2,3,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,5,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,1,2,3,4,36,21,22,23,27,5,30,1,1,2,3,9,10,11,11,12,12,13,13,14,14,14,15,17,4,18,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,5,29,30,15,15,5,5,5,109,109,109,109,0,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,95,95,0,95,95,0,0,0,0,0,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,0,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,0,0,0,0,0,0,0,72,73,72,73,99,72,73,100,99,72,73,100,0,99,72,73,100,99,72,73,100,100,100,72,73,99,72,72,73,73,100,99,72,72,73,73,100,99,72,73,100,0,72,73,99,72,73,100,99,99,72,72,73,73,100,100,99,72,73,100,99,72,73,100,100,99,100,72,72,72,72,72,72,72,72,72,73,99,72,73,100,99,72,72,72,72,72,72,72,73,73,73,73,73,73,73,100,72,73,99,72,73,100,99,72,73,100,72,72,72,72,100,0,0,0,0,0,104,106,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,104,105,106,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,104,106,108,104,105,106,107,108,108,104,105,106,107,108,104,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,110,110,111,111,112,112],"f":"``````````````````````````````````````````````````````````````````````````````````{{bb}b}{{dd}d}{{ff}f}{{hh}h}{{jj}j}{{bb}l}{{dd}l}{{ff}l}{{hh}l}`{c{{A`{n}}}{}}0000000000000{Ab{{A`{n}}}}{Ad{{A`{n}}}}{Af{{A`{n}}}}{Ah{{A`{n}}}}{Aj{{A`{n}}}}{Al{{A`{n}}}}{An{{A`{n}}}}{An{{B`{n}}}}{Bb{{A`{n}}}}{Bd{{A`{n}}}}{Bf{{A`{n}}}}{Bh{{A`{n}}}}{Bj{{B`{n}}}}{Bl{{B`{n}}}}{Bn{{B`{n}}}}???????????{c{{Cb{{A`{e}}C`}}}{}Cd}0000000000?>=<;:987654321{Cf{{A`{n}}}}{Ch{{A`{n}}}}{Cj{{A`{n}}}}{{{Cl{c}}}{{A`{c}}}Cn}44444444444444{{bD`}{{Db{b}}}}{{dD`}{{Db{d}}}}{{fD`}{{Db{f}}}}{{hD`}{{Db{h}}}}{{cc}c{DdDf}}{ce{}{}}0000000000000000000000000000000000000000000000000000000000000000000{{jj}{{Db{j}}}}00{{hh}{{Db{h}}}}1```{bb}{dd}{ff}{AbAb}{AdAd}{AfAf}{AhAh}{AjAj}{AlAl}{AnAn}{BbBb}{hh}{BdBd}{DhDh}{BfBf}{DjDj}{BhBh}{DlDl}{DnDn}{BjBj}{BlBl}{BnBn}{E`E`}{CfCf}{ChCh}{EbEb}{EdEd}{EfEf}{{{Eh{ce}}}{{Eh{ce}}}CnCn}{jj}{EjEj}{CjCj}{{{Cl{c}}}{{Cl{c}}}Cn}{{ce}l{}{}}00000000000000000000000000000000{{bb}El}{{dd}El}{{ff}El}{{AlAl}El}{{AnAn}El}{{BbBb}El}{{hh}El}{{DhDh}El}{{CfCf}El}{{ChCh}El}{{EbEb}El}{{EdEd}El}{{jj}El}{{EjEj}El}{{CjCj}El}{AnAf}0`{c{{Cb{bEn}}}F`}{c{{Cb{dEn}}}F`}{c{{Cb{fEn}}}F`}{c{{Cb{AfEn}}}F`}{c{{Cb{AhEn}}}F`}{c{{Cb{AjEn}}}F`}{c{{Cb{AlEn}}}F`}{c{{Cb{AnEn}}}F`}{c{{Cb{BbEn}}}F`}{c{{Cb{hEn}}}F`}{c{{Cb{BdEn}}}F`}{c{{Cb{DhEn}}}F`}{c{{Cb{DjEn}}}F`}{c{{Cb{BhEn}}}F`}{c{{Cb{DnEn}}}F`}{c{{Cb{BjEn}}}F`}{c{{Cb{BlEn}}}F`}{c{{Cb{BnEn}}}F`}{c{{Cb{E`En}}}F`}{c{{Cb{CfEn}}}F`}{c{{Cb{ChEn}}}F`}{c{{Cb{EbEn}}}F`}{c{{Cb{EdEn}}}F`}{c{{Cb{EfEn}}}F`}{c{{Cb{{Eh{eg}}En}}}F`FbFb}{c{{Cb{jEn}}}F`}{c{{Cb{CjEn}}}F`}{c{{Cb{{Cl{e}}En}}}F`{}}{{{A`{n}}}{{Cb{cEn}}}{}}000000000000000000000000000{{Fd{A`{n}}}{{Cb{cEn}}}{}}000000000000000000000000000{{c{Ff{b}}}{{Cb{FhEn}}}F`}{{c{Ff{d}}}{{Cb{FhEn}}}F`}{{c{Ff{f}}}{{Cb{FhEn}}}F`}{{c{Ff{Af}}}{{Cb{FhEn}}}F`}{{c{Ff{Ah}}}{{Cb{FhEn}}}F`}{{c{Ff{Aj}}}{{Cb{FhEn}}}F`}{{c{Ff{An}}}{{Cb{FhEn}}}F`}{{c{Ff{h}}}{{Cb{FhEn}}}F`}{{c{Ff{Bd}}}{{Cb{FhEn}}}F`}{{c{Ff{Dh}}}{{Cb{FhEn}}}F`}{{c{Ff{Dj}}}{{Cb{FhEn}}}F`}{{Fdc}{{Cb{eEn}}}F`{}}000000000000000000000000000{{}b}{{}d}{{}f}{{}Ab}{{}Ad}{{}Af}{{}Ah}{{}Aj}{{}Al}{{}An}{{}Bb}{{}h}{{}Bd}{{}Bf}{{}Dj}{{}Bh}{{}Dn}{{}Bj}{{}Bl}{{}Bn}{{}E`}{{}Cf}{{}Eb}{{}j}{D`c{}}00{Abc{}}1{Adc{}}22{Afc{}}3{Ahc{}}4{Ajc{}}5{Alc{}}6{Anc{}}{Bbc{}}888{Bdc{}}{Dhc{}}::{Bfc{}}{Djc{}}<<{Bhc{}}={Dlc{}}>{Dnc{}}?{Bjc{}}{Blc{}}{D`c{}}{Bnc{}}11{E`c{}}2{Cfc{}}{Chc{}}444444{Ejc{}}5555555{Abc{}}66{Adc{}}7{Afc{}}{Ahc{}}99{Ajc{}}:{Alc{}};{Anc{}}<{Bbc{}}=={Bdc{}}{Dhc{}}??{Bfc{}}{Djc{}}{D`c{}}000{Dnc{}}1{Bjc{}}2{Blc{}}3{Bnc{}}{E`c{}}555555555555{{CjfDh}Dl}{{CjDhBdDh}{{Db{Dh}}}}{{BhFj}Fl}{BnBh}{{CjfDhFnDh{G`{DhDh}}}d}{{CjFl}Ej}{c{{Cb{b}}}Gb}{c{{Cb{d}}}Gb}{c{{Cb{f}}}Gb}{c{{Cb{Af}}}Gb}{c{{Cb{Ah}}}Gb}{c{{Cb{Aj}}}Gb}{c{{Cb{Al}}}Gb}{c{{Cb{An}}}Gb}{c{{Cb{Bb}}}Gb}{c{{Cb{h}}}Gb}{c{{Cb{Bd}}}Gb}{c{{Cb{Dh}}}Gb}{c{{Cb{Dj}}}Gb}{c{{Cb{Bh}}}Gb}{c{{Cb{Dn}}}Gb}{c{{Cb{Bj}}}Gb}{c{{Cb{Bl}}}Gb}{c{{Cb{Bn}}}Gb}{c{{Cb{Cf}}}Gb}{c{{Cb{Ch}}}Gb}{c{{Cb{Eb}}}Gb}{c{{Cb{Ed}}}Gb}{c{{Cb{Ef}}}Gb}{c{{Cb{{Eh{eg}}}}}GbGdGd}{c{{Cb{Cj}}}Gb}{{bc}b{}}{{dc}d{}}{{fc}f{}}{{hc}h{}}{{jc}j{}}{{bc}l{}}{{dc}l{}}{{fc}l{}}{{hc}l{}}{D`l}000000000000000000000000000000000{b{{Gf{n}}}}{d{{Gf{n}}}}{f{{Gf{n}}}}{Af{{Gf{n}}}}{Ah{{Gf{n}}}}{Aj{{Gf{n}}}}{Al{{Gf{n}}}}{An{{Gf{n}}}}{Bb{{Gf{n}}}}{h{{Gf{n}}}}{Bd{{Gf{n}}}}{Dh{{Gf{n}}}}{Dj{{Gf{n}}}}{Bh{{Gf{n}}}}{Dn{{Gf{n}}}}{Bj{{Gf{n}}}}{Bl{{Gf{n}}}}{Bn{{Gf{n}}}}{E`{{Gf{n}}}}{Cf{{Gf{n}}}}{Ch{{Gf{n}}}}{j{{Gf{n}}}}{Cj{{Gf{n}}}}{{{Cl{c}}}{{Gf{n}}}{}}{ce{}{{Gj{Gh}}}}000000000000000000000000000{{bc}l{GlGn}}{{dc}l{GlGn}}{{fc}l{GlGn}}{{Afc}l{GlGn}}{{Ahc}l{GlGn}}{{Ajc}l{GlGn}}{{Alc}l{GlGn}}{{Anc}l{GlGn}}{{Bbc}l{GlGn}}{{hc}l{GlGn}}{{Bdc}l{GlGn}}{{Dhc}l{GlGn}}{{Djc}l{GlGn}}{{Bhc}l{GlGn}}{{Dnc}l{GlGn}}{{Bjc}l{GlGn}}{{Blc}l{GlGn}}{{Bnc}l{GlGn}}{{E`c}l{GlGn}}{{Cfc}l{GlGn}}{{Chc}l{GlGn}}{{Ebc}l{GlGn}}{{Edc}l{GlGn}}{{Efc}l{GlGn}}{{{Eh{ce}}g}lH`H`{GlGn}}{{jc}l{GlGn}}{{Cjc}l{GlGn}}{{{Cl{c}}e}l{}{GlGn}}{{bb}Hb}{{dd}Hb}{{ff}Hb}{{AbAb}Hb}{{AdAd}Hb}{{AfAf}Hb}{{AhAh}Hb}{{AjAj}Hb}{{AlAl}Hb}{{AnAn}Hb}{{BbBb}Hb}{{hh}Hb}{{BdBd}Hb}{{DhDh}Hb}{{BfBf}Hb}{{DjDj}Hb}{{BhBh}Hb}{{DlDl}Hb}{{DnDn}Hb}{{BjBj}Hb}{{BlBl}Hb}{{BnBn}Hb}{{E`E`}Hb}{{CfCf}Hb}{{ChCh}Hb}{{EbEb}Hb}{{EdEd}Hb}{{EfEf}Hb}{{{Eh{ce}}{Eh{ce}}}HbHdHd}{{jj}Hb}{{EjEj}Hb}{{CjCj}Hb}{{{Cl{c}}{Cl{c}}}HbHd}{{{Cl{c}}}cCn}{hd}{{bHf}Hh}0{{dHf}Hh}0{{fHf}Hh}0{{AbHf}Hh}{{AdHf}Hh}{{AfHf}Hh}{{AhHf}Hh}{{AjHf}Hh}{{AlHf}Hh}{{AnHf}Hh}{{BbHf}Hh}{{hHf}Hh}0{{BdHf}Hh}{{DhHf}Hh}0{{BfHf}Hh}{{DjHf}Hh}{{BhHf}Hh}{{DlHf}Hh}{{DnHf}Hh}{{BjHf}Hh}0{{BlHf}Hh}0{{BnHf}Hh}0{{E`Hf}Hh}{{CfHf}Hh}0{{ChHf}Hh}{{EbHf}Hh}{{EdHf}Hh}{{EfHf}Hh}{{{Eh{ce}}Hf}HhHjHj}{{jHf}Hh}0{{EjHf}Hh}{{CjHf}Hh}{{{Cl{c}}Hf}HhHj}{{HlHf}Hh}{{bD`}{{Db{b}}}}{{dD`}{{Db{d}}}}{{fD`}{{Db{f}}}}{{hD`}{{Db{h}}}}{cc{}}{Fnb}1{Hnd}2{Fnf}333{{{B`{n}}}Af}{I`Af}{{{B`{n}}}Ah}6{IbAh}{{{B`{n}}}Aj}{IbAj}99{AnAl}:{AnBb};;{Hnh}{{{B`{n}}}Bd}{I`Bd}>{hDh}{IdDh}{cc{}}00{{{B`{n}}}Bh}11{{{B`{n}}}Dl}2{{{B`{n}}}Dn}3{{{B`{n}}}Bj}{{{B`{n}}}Bl}55{{{B`{n}}}Bn}66{{{B`{n}}}Cf}7{{{B`{n}}}Ch}8888{nj}{Hnj}{Ifj}{Fnj}<{Fdj}===={{{B`{n}}}j}{{{B`{n}}}d}{{{A`{n}}{A`{n}}}Bl}{c{{Cb{Ane}}}{{Ih{{A`{n}}}}}{}}{c{{Cb{Bbe}}}{{Ih{{A`{n}}}}}{}}{c{{Cb{Dne}}}{{Ih{{A`{n}}}}}{}}5{Ij{{Cb{Bjc}}}{}}{{ce}{{Eh{ce}}}{}{}}{{bc}lIl}{{dc}lIl}{{fc}lIl}{{Afc}lIl}{{Ahc}lIl}{{Ajc}lIl}{{Alc}lIl}{{Anc}lIl}{{Bbc}lIl}{{hc}lIl}{{Bdc}lIl}{{Dhc}lIl}{DnFl}{{Blc}lIl}{{Bnc}lIl}{{E`c}lIl}{{Cfc}lIl}{CfFl}{{Chc}lIl}{{Ebc}lIl}{{Edc}lIl}{EfFl}{{Efc}lIl}{{jc}lIl}{{Ejc}lIl}{{Cjc}lIl}`{DhId}{{}D`}000000000000000000000000000000000{ce{}{}}000000000000000000000000000000000{Bb{{Gf{An}}}}{{{Eh{ci}}}{{Eh{ce}}}{}{}{{In{e}}}{{In{g}}}}{{{Cl{c}}}{{Jb{J`}}}Cn}0{BlBj}{{{Cl{c}}}cCn}{EfEd}{hd}{{{Cl{c}}}D`Cn}99999999999999999{{bc}b{}}{{dc}d{}}{{fc}f{}}{{hc}h{}}{{jc}j{}}{{bc}l{}}{{dc}l{}}{{fc}l{}}{{hc}l{}}{D`Bb}{Hnh}{IdDh}{{FlJd}Cj}{{{Gf{c}}}{{Cb{{Cl{c}}Hl}}}Cn}{{}{{Jb{Ab}}}}{{}{{Jb{Ad}}}}{{}{{Jb{An}}}}{{}{{Jb{Bf}}}}{c{{Cl{c}}}Cn}{D`{{Gf{Ad}}}}``{{}j}{E`Bn}{Bb{{`{{Jh{}{{Jf{An}}}}}}}}000{Bb{{`{{Jj{}{{Jf{An}}}}}}}}0{Eb{{Db{Fd}}}}{Ed{{Db{Fd}}}}{{bb}{{Db{El}}}}{{dd}{{Db{El}}}}{{ff}{{Db{El}}}}{{AlAl}{{Db{El}}}}{{AnAn}{{Db{El}}}}{{BbBb}{{Db{El}}}}{{hh}{{Db{El}}}}{{DhDh}{{Db{El}}}}{{CfCf}{{Db{El}}}}{{ChCh}{{Db{El}}}}{{EbEb}{{Db{El}}}}{{EdEd}{{Db{El}}}}{{jj}{{Db{El}}}}{{EjEj}{{Db{El}}}}{{CjCj}{{Db{El}}}}`{dFd}{EfFl}``{{{Cl{c}}c}lCn}{AnAd}`0`{{jc}j{}}`{Ejb}{{jj}j}00{{DhDh}{{Db{Dh}}}}`{BnBl}{{BnFl}Bl}{EfBd}{dh}{Dhh}{Efh}{h{{B`{d}}}}0{{bc}CbJl}{{dc}CbJl}{{fc}CbJl}{{Afc}CbJl}{{Ahc}CbJl}{{Ajc}CbJl}{{Alc}CbJl}{{Anc}CbJl}{{Bbc}CbJl}{{hc}CbJl}{{Bdc}CbJl}{{Dhc}CbJl}{{Djc}CbJl}{{Bhc}CbJl}{{Dnc}CbJl}{{Bjc}CbJl}{{Blc}CbJl}{{Bnc}CbJl}{{Cfc}CbJl}{{Chc}CbJl}{{Ebc}CbJl}{{Edc}CbJl}{{Efc}CbJl}{{{Eh{ce}}g}CbJnJnJl}{{Cjc}CbJl}{Edl}{{EbFd}l}{{EdK`}l}{bD`}{dD`}{fD`}{AfD`}{AhD`}{AjD`}{AlD`}{AnD`}{BbD`}{hD`}{BdD`}{DhD`}{DjD`}{BhD`}{DnD`}{BjD`}{BlD`}{BnD`}{E`D`}{CfD`}{ChD`}{EbD`}{EdD`}{EfD`}{{{Eh{ce}}}D`H`H`}{jD`}{CjD`}{{{Cl{c}}}D`{}}{{{A`{{B`{n}}}}}{{A`{Ad}}}}0{{{A`{Ad}}}{{A`{{B`{n}}}}}}0{Bb{{`{{Jj{}{{Jf{An}}}}}}}}0{An{{G`{AdAfAh}}}}0{{bb}{{Db{D`}}}}{{dd}{{Db{D`}}}}{{ff}{{Db{D`}}}}{{hh}{{Db{D`}}}}{{bb}b}{{dd}d}{{ff}f}{{hh}h}{{jj}j}{{bb}l}{{dd}l}{{ff}l}{{hh}l}{j{{B`{n}}}}{d{{B`{n}}}}{f{{B`{n}}}}{{c{A`{n}}}{{Gf{n}}}{}}0000000000000000000000000003{ce{}{}}00000000000000000000000000000000{cKb{}}000000000{{{Cl{c}}}{{Gf{c}}}Cn}{D`{{Cb{bc}}}{}}{c{{Cb{e}}}{}{}}0000{{{A`{n}}}{{Cb{Afc}}}{}}11{{{A`{n}}}{{Cb{Ahc}}}{}}{{{A`{n}}}{{Cb{Ajc}}}{}}3{{{Gf{n}}}{{Cb{Alc}}}{}}{{{A`{n}}}{{Cb{Alc}}}{}}5555{{{A`{n}}}{{Cb{Bdc}}}{}}66666666666666666666666666666666666666666666666666666666{cKd{}}000000000000000000000000000000000{{}Kf}00000000000000000000000000{{be}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{de}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{fe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Afe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ahe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Aje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ale}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ane}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bbe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{he}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bde}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Dhe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Dje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bhe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Dne}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ble}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bne}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{E`e}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Cfe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Che}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{je}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Cje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{{Cl{c}}g}e{}{}{{Kj{{A`{n}}}{{Kh{e}}}}}}{AnAh}0{{jj}j}0{{}j}`````{ce{}{}}0{{{Kl{c}}}{{Kl{c}}}Cn}{{ce}l{}{}}{c{{Cb{{Kl{e}}En}}}F`Fb}{{{A`{n}}}{{Cb{cEn}}}{}}{{Fd{A`{n}}}{{Cb{cEn}}}{}}{{Fdc}{{Cb{eEn}}}F`{}}{D`c{}}0{D`l}{{{Kl{c}}e}lH`{GlGn}}{{{Kl{c}}}D`H`}{{{Kl{c}}Hf}HhHj}{cc{}}{{}D`}=3{{c{A`{n}}}{{Gf{n}}}{}}>{c{{Cb{e}}}{}{}}0{cKd{}}```{KnL`}0{{{A`{n}}}Kn}{{{A`{n}}}Fl}{{{A`{{A`{n}}}}}Fl}1{{{B`{n}}{A`{n}}}Fl}{ce{}{}}0{KnKn}{{ce}l{}{}}{{KnKn}El}{c{{Cb{KnEn}}}F`}{{{A`{n}}}{{Cb{cEn}}}{}}{{Fd{A`{n}}}{{Cb{cEn}}}{}}{{Fdc}{{Cb{eEn}}}F`{}}{{}Kn}{Knc{}}{D`c{}}10{c{{Cb{Kn}}}Gb}{D`l}{{}{{Db{D`}}}}{KnD`}{{KnKn}Hb}{{KnHf}Hh}{{{B`{n}}}Kn}{L`Kn}{cc{}}2{{Knc}lIl}{{}D`}{ce{}{}}`1{{KnKn}{{Db{El}}}}{{Knc}CbJl}:{{{A`{L`}}}{{A`{Kn}}}}0{{{A`{Kn}}}{{A`{L`}}}}{{{A`{{Db{L`}}}}}{{A`{{Db{Kn}}}}}}0{{{A`{{Db{Kn}}}}}{{A`{{Db{L`}}}}}}02{Kn{{B`{n}}}}{{c{A`{n}}}{{Gf{n}}}{}}8{{{B`{n}}}{{Cb{Knc}}}{}}{c{{Cb{e}}}{}{}}10{cKd{}}{{}Kf}{{Kne}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{{Gf{L`}}}{{Gf{Kn}}}}{{{Gf{{Db{L`}}}}}{{Gf{{Db{Kn}}}}}}{{{Gf{{Db{Kn}}}}}{{Gf{{Db{L`}}}}}}{{{Gf{Kn}}}{{Gf{L`}}}}```````{I`Lb}{IbLb}10{ce{}{}}0000000{{{A`{n}}D`D`}{{Cb{LdKb}}}}{LfLf}{I`I`}{IbIb}{LhLh}{{ce}l{}{}}000{{LhLf}{{Cb{I`Kb}}}}{{LhLfD`Fd}{{Cb{IbKb}}}}{{}I`}{{}Ib}{D`c{}}0{I`c{}}{Ibc{}}22221202{D`l}000{{}Ld}{{I`I`}Hb}{{IbIb}Hb}{{LfHf}Hh}{{I`Hf}Hh}{{IbHf}Hh}{{LhHf}Hh}{cc{}}{LjLf}1{LbI`}2{LbIb}3{{LhD`}{{Cb{{Ln{Ll}}Kb}}}}{{}D`}000{ce{}{}}000{LdLh}{Lfl}{{Lh{A`{Kn}}}{{Cb{LfKb}}}}{{{A`{Lb}}}{{A`{I`}}}}0{{{A`{I`}}}{{A`{Lb}}}}{{{A`{{Db{Lb}}}}}{{A`{{Db{I`}}}}}}0{{{A`{{Db{I`}}}}}{{A`{{Db{Lb}}}}}}02{I`{{B`{n}}}}{Ib{{B`{n}}}}9999{c{{Cb{e}}}{}{}}{Bd{{Cb{I`c}}}{}}{Af{{Cb{I`c}}}{}}{{{B`{n}}}{{Cb{I`c}}}{}}23013{Aj{{Cb{Ibc}}}{}}{Ah{{Cb{Ibc}}}{}}{{{B`{n}}}{{Cb{Ibc}}}{}}1206{{{B`{n}}}{{Cb{I`Kb}}}}{{{B`{n}}}{{Cb{IbKb}}}}8888{cKd{}}000{{{Gf{Lb}}}{{Gf{I`}}}}{{{Gf{{Db{Lb}}}}}{{Gf{{Db{I`}}}}}}{{{Gf{{Db{I`}}}}}{{Gf{{Db{Lb}}}}}}{{{Gf{I`}}}{{Gf{Lb}}}}{{LhI`D`FdKnIb}Hb}````````{ce{}{}}000000000{M`M`}{MbMb}{MdMd}{MfMf}{MhMh}{{ce}l{}{}}0000{{M`M`}El}{{MbMb}El}{{MdMd}El}{{MfMf}El}{{MhMh}El}{c{{Cb{M`En}}}F`}{c{{Cb{MbEn}}}F`}{c{{Cb{MdEn}}}F`}{c{{Cb{MfEn}}}F`}{c{{Cb{MhEn}}}F`}{{{A`{n}}}{{Cb{cEn}}}{}}0000{{Fd{A`{n}}}{{Cb{cEn}}}{}}0000{{Fdc}{{Cb{eEn}}}F`{}}0000{{}Mb}{{}Mf}{D`c{}}000000000{c{{Cb{M`}}}Gb}{c{{Cb{Mb}}}Gb}{c{{Cb{Md}}}Gb}{c{{Cb{Mf}}}Gb}{c{{Cb{Mh}}}Gb}{D`l}0000{Mb{{Gf{n}}}}{Mf{{Gf{n}}}}{{M`c}l{GlGn}}{{Mbc}l{GlGn}}{{Mdc}l{GlGn}}{{Mfc}l{GlGn}}{{Mhc}l{GlGn}}{{M`M`}Hb}{{MbMb}Hb}{{MdMd}Hb}{{MfMf}Hb}{{MhMh}Hb}{{M`Hf}Hh}{{MbHf}Hh}{{MdHf}Hh}{{MfHf}Hh}{{MhHf}Hh}{cc{}}0000{{M`c}lIl}{M`Fl}{{Mbc}lIl}{{Mdc}lIl}{MdFl}{{Mfc}lIl}{{Mhc}lIl}{{}D`}0000{ce{}{}}0000``{M`Fd}{MdFd}{MhFd}{{M`M`}{{Db{El}}}}{{MbMb}{{Db{El}}}}{{MdMd}{{Db{El}}}}{{MfMf}{{Db{El}}}}{{MhMh}{{Db{El}}}}{Mhd}{{M`c}CbJl}{{Mbc}CbJl}{{Mdc}CbJl}{{Mfc}CbJl}{{Mhc}CbJl}{{M`Fd}l}{M`D`}{MbD`}{MdD`}{MfD`}{MhD`}{{c{A`{n}}}{{Gf{n}}}{}}0000{ce{}{}}0000{c{{Cb{e}}}{}{}}000000000{cKd{}}0000{{}Kf}0000{{Mbe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Mfe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}``````","c":[],"p":[[5,"SBucket",0],[5,"PieceIndex",0],[5,"PieceOffset",0],[5,"SegmentIndex",0],[5,"U256",0],[1,"unit"],[1,"u8"],[1,"slice"],[5,"RawRecord",0],[5,"Record",0],[5,"RecordCommitment",0],[5,"RecordWitness",0],[5,"ChunkWitness",0],[5,"Piece",0],[5,"PieceArray",0],[1,"array"],[5,"FlatPieces",0],[5,"SegmentCommitment",0],[5,"RecordedHistorySegment",0],[5,"Randomness",0],[5,"PotKey",0],[5,"PotSeed",0],[5,"PotOutput",0],[6,"Error",1802],[6,"Result",1803],[10,"FromByteSlice",1802],[5,"PublicKey",0],[5,"RewardSignature",0],[5,"SectorId",0],[5,"NonEmptyVec",0],[10,"Clone",1804],[1,"usize"],[6,"Option",1805],[10,"WrappingSub",1806],[10,"Ord",1807],[5,"HistorySize",0],[5,"ArchivedHistorySegment",0],[5,"PosSeed",0],[5,"PosProof",0],[5,"PotCheckpoints",0],[6,"ArchivedBlockProgress",0],[5,"LastArchivedBlock",0],[6,"SegmentHeader",0],[5,"Solution",0],[5,"SectorSlotChallenge",0],[6,"Ordering",1807],[5,"Error",1808],[10,"Input",1809],[10,"Decode",1809],[1,"u32"],[20,"MaybeUninit",1810],[5,"DecodeFinished",1811],[8,"SlotNumber",0],[8,"Blake3Hash",0],[1,"u16"],[1,"tuple"],[10,"Deserializer",1812],[10,"Deserialize",1812],[5,"Vec",1813],[1,"char"],[10,"FromIterator",1814],[10,"Output",1809],[10,"Sized",1815],[10,"Encode",1809],[1,"bool"],[10,"PartialEq",1807],[5,"Formatter",1816],[8,"Result",1816],[10,"Debug",1816],[6,"NonEmptyVecErr",0],[1,"u64"],[5,"Commitment",1509],[5,"Witness",1509],[5,"NonZeroU64",1817],[1,"u128"],[10,"AsRef",1818],[1,"str"],[10,"Hasher",1819],[10,"Into",1818],[10,"Iterator",1820],[5,"Box",1821],[8,"SectorIndex",0],[17,"Item"],[10,"IndexedParallelIterator",1822],[10,"ExactSizeIterator",1823],[10,"Serializer",1824],[10,"Serialize",1824],[8,"BlockNumber",0],[5,"String",1825],[5,"TypeId",1826],[5,"Type",1827],[17,"Output"],[10,"FnOnce",1828],[5,"Blake3Checksummed",1421],[5,"Scalar",1445],[5,"FsFr",1829],[5,"FsG1",1830],[5,"FsKZGSettings",1831],[5,"Polynomial",1509],[5,"Kzg",1509],[5,"FsPoly",1832],[5,"FsFFTSettings",1833],[5,"Arc",1834],[6,"BlockObject",1628],[5,"BlockObjectMapping",1628],[6,"PieceObject",1628],[5,"PieceObjectMapping",1628],[6,"GlobalObject",1628],[15,"V0",1417],[15,"V0",1796],[15,"V0",1798],[15,"V0",1800]],"b":[[112,"impl-AsMut%3C%5Bu8%5D%3E-for-PieceArray"],[113,"impl-AsMut%3C%5Bu8;+Piece::SIZE%5D%3E-for-PieceArray"],[149,"impl-AsRef%3C%5Bu8%5D%3E-for-PieceArray"],[150,"impl-AsRef%3C%5Bu8;+Piece::SIZE%5D%3E-for-PieceArray"],[784,"impl-Debug-for-SBucket"],[785,"impl-Display-for-SBucket"],[786,"impl-Display-for-PieceIndex"],[787,"impl-Debug-for-PieceIndex"],[788,"impl-Display-for-PieceOffset"],[789,"impl-Debug-for-PieceOffset"],[798,"impl-Debug-for-SegmentIndex"],[799,"impl-Display-for-SegmentIndex"],[801,"impl-Debug-for-HistorySize"],[802,"impl-Display-for-HistorySize"],[808,"impl-Debug-for-PotKey"],[809,"impl-Display-for-PotKey"],[810,"impl-Display-for-PotSeed"],[811,"impl-Debug-for-PotSeed"],[812,"impl-Debug-for-PotOutput"],[813,"impl-Display-for-PotOutput"],[815,"impl-Debug-for-PublicKey"],[816,"impl-Display-for-PublicKey"],[822,"impl-Display-for-U256"],[823,"impl-Debug-for-U256"],[841,"impl-From%3C%5Bu8;+RecordCommitment::SIZE%5D%3E-for-RecordCommitment"],[842,"impl-From%3CCommitment%3E-for-RecordCommitment"],[843,"impl-From%3C%5Bu8;+RecordWitness::SIZE%5D%3E-for-RecordWitness"],[845,"impl-From%3CWitness%3E-for-RecordWitness"],[846,"impl-From%3C%5Bu8;+ChunkWitness::SIZE%5D%3E-for-ChunkWitness"],[847,"impl-From%3CWitness%3E-for-ChunkWitness"],[856,"impl-From%3C%5Bu8;+SegmentCommitment::SIZE%5D%3E-for-SegmentCommitment"],[857,"impl-From%3CCommitment%3E-for-SegmentCommitment"],[859,"impl-From%3CSegmentIndex%3E-for-HistorySize"],[860,"impl-From%3CNonZeroU64%3E-for-HistorySize"],[885,"impl-From%3Cu8%3E-for-U256"],[886,"impl-From%3Cu64%3E-for-U256"],[887,"impl-From%3Cu128%3E-for-U256"],[888,"impl-From%3Cu16%3E-for-U256"],[890,"impl-From%3Cu32%3E-for-U256"],[920,"impl-Hash-for-PublicKey"],[921,"impl-PublicKey"],[925,"impl-SegmentHeader"],[926,"impl-Hash-for-SegmentHeader"],[1264,"impl-TryFrom%3CVec%3Cu8%3E%3E-for-Piece"],[1265,"impl-TryFrom%3C%26%5Bu8%5D%3E-for-Piece"],[1475,"impl-From%3C%5Bu8;+Self::SAFE_BYTES%5D%3E-for-Scalar"],[1476,"impl-From%3CFsFr%3E-for-Scalar"],[1478,"impl-From%3C%26%5Bu8;+Self::SAFE_BYTES%5D%3E-for-Scalar"],[1498,"impl-TryFrom%3C%5Bu8;+Self::FULL_BYTES%5D%3E-for-Scalar"],[1500,"impl-TryFrom%3C%26%5Bu8;+Self::FULL_BYTES%5D%3E-for-Scalar"],[1598,"impl-TryFrom%3CSegmentCommitment%3E-for-Commitment"],[1599,"impl-TryFrom%3CRecordCommitment%3E-for-Commitment"],[1600,"impl-TryFrom%3C%5Bu8;+Self::SIZE%5D%3E-for-Commitment"],[1601,"impl-TryFrom%3C%26SegmentCommitment%3E-for-Commitment"],[1603,"impl-TryFrom%3C%26%5Bu8;+Self::SIZE%5D%3E-for-Commitment"],[1604,"impl-TryFrom%3C%26RecordCommitment%3E-for-Commitment"],[1606,"impl-TryFrom%3C%26ChunkWitness%3E-for-Witness"],[1607,"impl-TryFrom%3C%26RecordWitness%3E-for-Witness"],[1608,"impl-TryFrom%3C%5Bu8;+Self::SIZE%5D%3E-for-Witness"],[1609,"impl-TryFrom%3CRecordWitness%3E-for-Witness"],[1610,"impl-TryFrom%3CChunkWitness%3E-for-Witness"],[1611,"impl-TryFrom%3C%26%5Bu8;+Self::SIZE%5D%3E-for-Witness"],[1725,"impl-Hash-for-BlockObject"],[1726,"impl-BlockObject"],[1728,"impl-Hash-for-PieceObject"],[1729,"impl-PieceObject"]]}],\
 ["subspace_erasure_coding",{"doc":"","t":"FNNNNNNNNNNNNNNNNNNNNNN","n":["ErasureCoding","borrow","borrow_mut","clone","clone_into","deref","deref_mut","drop","extend","extend_commitments","fmt","from","init","into","max_shards","new","recover","recover_poly","recover_source","to_owned","try_from","try_into","type_id"],"q":[[0,"subspace_erasure_coding"],[23,"subspace_core_primitives::crypto"],[24,"alloc::vec"],[25,"alloc::string"],[26,"core::result"],[27,"subspace_core_primitives::crypto::kzg"],[28,"core::fmt"],[29,"core::fmt"],[30,"core::option"],[31,"subspace_core_primitives::crypto::kzg"],[32,"core::any"]],"d":["Erasure coding abstraction.","","","","","","","","Extend sources using erasure coding.","Extend commitments using erasure coding.","","Returns the argument unchanged.","","Calls U::from(self).","Max number of shards supported (both source and parity …","Create new erasure coding instance.","Recovery of missing shards from given shards (at least 1/2 …","Recovery of missing shards from given shards (at least 1/2 …","Recovery of source shards from given shards (at least 1/2 …","","","",""],"i":[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],"f":"`{ce{}{}}0{bb}{{ce}d{}{}}{fc{}}0{fd}{{b{j{h}}}{{A`{{l{h}}n}}}}{{b{j{Ab}}}{{A`{{l{Ab}}n}}}}{{bAd}Af}{cc{}}{{}f}9{bf}{Ah{{A`{bn}}}}{{b{j{{Aj{h}}}}}{{A`{{l{h}}n}}}}{{b{j{{Aj{h}}}}}{{A`{Aln}}}}{{b{j{{Aj{h}}}}}{{A`{{`{{B`{}{{An{h}}}}}}n}}}}>{c{{A`{e}}}{}{}}0{cBb{}}","c":[],"p":[[5,"ErasureCoding",0],[1,"unit"],[1,"usize"],[5,"Scalar",23],[1,"slice"],[5,"Vec",24],[5,"String",25],[6,"Result",26],[5,"Commitment",27],[5,"Formatter",28],[8,"Result",28],[5,"NonZeroUsize",29],[6,"Option",30],[5,"Polynomial",27],[17,"Item"],[10,"ExactSizeIterator",31],[5,"TypeId",32]],"b":[]}],\
 ["subspace_farmer",{"doc":"subspace-farmer library implementation overview","t":"FSEFENNNNNNNNNNNNNNNNNNNNNNNNNNNENNCNNNCNCNNNCNNNNNNCNNNNNNNNNNCNNIKKMMMMMMMMMMMFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHPPGPPPPPPPPPPPPPPPPPPPPPPPPPPPEPPPPPPPPPPPPTPPPPPTPPPGPPGGGFGGGFFGGPPPPPPPPNONNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNOOOCONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONONNNONNNNCNOCNNNNOONNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPFPFPPPGGPPPPFFPFGPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONOCOOOONNNNNONNOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOFNNNNNNNNNNNNNNNNPPFGPFPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOFNNNNNNNNNNNNNNNNNNFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNFFHNNNNNNNHNNNNNNNCNNNNNNNNNHCNNHCHHCHNHNNNNNNNNNNNNFNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNNPPPPPGNNNNNNNNNNHNNNNNN","n":["Identity","KNOWN_PEERS_CACHE_SIZE","NodeClient","NodeRpcClient","RpcClientError","acknowledge_archived_segment_header","borrow","borrow","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","create","deref","deref","deref","deref_mut","deref_mut","drop","drop","entropy","farmer_app_info","file_size","fmt","from","from","init","init","into","into","jsonrpsee","last_segment_headers","new","node_client","open","open_or_create","piece","piece_cache","public_key","reward_signing","secret_key","segment_headers","sign_reward_hash","single_disk_farm","submit_reward_signature","submit_solution_response","subscribe_archived_segment_headers","subscribe_node_sync_status_change","subscribe_reward_signing","subscribe_slot_info","thread_pool_manager","to_owned","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","unique_saturated_into","unique_saturated_into","utils","vzip","vzip","Error","NodeClient","NodeClientExt","acknowledge_archived_segment_header","farmer_app_info","last_segment_headers","piece","segment_headers","submit_reward_signature","submit_solution_response","subscribe_archived_segment_headers","subscribe_node_sync_status_change","subscribe_reward_signing","subscribe_slot_info","CacheWorker","PieceCache","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deref","deref","deref_mut","deref_mut","drop","drop","fmt","fmt","from","from","get_piece","init","init","into","into","new","on_sync_progress","record","replace_backing_caches","run","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","unique_saturated_into","unique_saturated_into","vzip","vzip","reward_signing","AboutToExpire","BackgroundDownloadingPanicked","BackgroundTaskError","BackgroundTaskPanicked","CacheCantBeOpened","CacheFileDoesNotExist","CantPreallocateMetadataFile","CantPreallocatePlotFile","Determined","Downloaded","Downloading","Encoded","Encoding","Error","Expiration","Expired","FailedToDecodeMetadataHeader","FailedToDecodeMetadataHeader","FailedToDetermineFileSize","FailedToGetFarmerInfo","FailedToGetSegmentHeader","FailedToOpenIdentity","FailedToReadBytes","FailedToSubscribeArchivedSegments","FailedToWriteBytes","FarmInfoCantBeOpened","FarmInfoFileDoesNotExist","FarmIsShuttingDown","FarmTooLarge","Farming","FarmingError","Finished","Found","IdentityCantBeOpened","IdentityFileDoesNotExist","IdentityMismatch","InsufficientAllocatedSpace","InvalidPiecesInSector","Io","Io","LikelyAlreadyInUse","LikelyAlreadyInUse","LowLevel","METADATA_FILE","MetadataCantBeOpened","MetadataFileDoesNotExist","MetadataFileTooSmall","MissingArchivedSegmentHeader","NotFound","PLOT_FILE","PieceCacheError","Plotting","Plotting","PlottingError","PublicKeyMismatch","RewardSigning","SectorExpirationDetails","SectorPlottingDetails","SectorUpdate","SingleDiskFarm","SingleDiskFarmError","SingleDiskFarmId","SingleDiskFarmInfo","SingleDiskFarmInfoLock","SingleDiskFarmOptions","SingleDiskFarmScrubError","SingleDiskFarmSummary","Starting","Ulid","UnexpectedMetadataVersion","UnexpectedMetadataVersion","V0","Writing","Written","WrongChain","allocated_space","allocated_space","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","cache_percentage","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","collect_summary","compare","decode","decode","decode","decode_all","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deserialize","deserialize","directory","downloading_semaphore","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","encode_to","encode_to","encode_to","eq","equivalent","equivalent","equivalent","erasure_coding","farm_during_initial_plotting","farmer_app_info","farming","farming_thread_pool_size","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","genesis_hash","hash","id","id","info","init","init","init","init","init","init","init","init","init","init","init","init","init","into","into","into","into","into","into","into","into","into","into","into","into","into","kzg","load_from","max_pieces_in_sector","new","new","new","node_client","on_farming_notification","on_sector_update","on_solution","partial_cmp","piece_cache","piece_cache","piece_getter","piece_reader","piece_reader","pieces_in_sector","plotted_sectors","plotted_sectors_count","plotting_delay","plotting_thread_pool_manager","public_key","read_all_sectors_metadata","reward_address","run","scrub","serialize","serialize","size_hint","size_hint","size_hint","source","source","source","store_to","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","to_string","total_sectors_count","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_lock","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","wipe","task","error","error","error","segment_index","expires_at","last_queued","old_plotted_sector","plotted_sector","progress","replotting","time","allocated_sectors","allocated_space","allocated_space","correct_chain","correct_public_key","id","id","id","initialized_with","max_sectors","max_space","max_supported","min_space","wrong_chain","wrong_public_key","allocated_space","genesis_hash","id","pieces_in_sector","public_key","error","error","error","error","error","error","error","file","file","file","file","file","file","file","file","file","file","file","file","identity","info","offset","offset","reserved_size","size","size","size","directory","directory","directory","error","info","Auditing","AuditingDetails","Decoded","DecodedFarmingError","FailedToCreateThreadPool","FailedToGetFarmerInfo","FailedToSubscribeSlotInfo","FarmingError","FarmingNotification","Io","LowLevelAuditing","LowLevelProving","NonFatalError","PlotAudit","PlotAuditOptions","Proving","ProvingDetails","ProvingResult","Rejected","Success","Timeout","audit","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","decode","decode","decode","decode","decode","decode","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","deref","deref","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","drop","drop","drop","drop","drop","drop","drop","drop","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","erasure_coding","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from","from","from","from","init","init","init","init","init","init","init","init","into","into","into","into","into","into","into","into","is_fatal","kzg","maybe_sector_being_modified","new","public_key","rayon_files","result","reward_address","sectors_count","sectors_metadata","size_hint","size_hint","size_hint","size_hint","size_hint","slot_info","source","str_variant","table_generator","time","time","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","error","error","RayonFiles","borrow","borrow_mut","deref","deref_mut","drop","from","init","into","open","read_at","read_at","try_from","try_into","type_id","unique_saturated_into","vzip","CantPreallocateCacheFile","ChecksumMismatch","DiskPieceCache","DiskPieceCacheError","Io","Offset","OffsetOutsideOfRange","ZeroCapacity","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","deref","deref","deref","deref_mut","deref_mut","deref_mut","drop","drop","drop","fmt","fmt","fmt","fmt","fmt","from","from","from","from","init","init","init","into","into","into","source","to_owned","to_owned","to_string","to_string","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","unique_saturated_into","unique_saturated_into","unique_saturated_into","vzip","vzip","vzip","max","provided","PieceReader","borrow","borrow_mut","clone","clone_into","deref","deref_mut","drop","fmt","from","init","into","read_piece","to_owned","try_from","try_into","type_id","unique_saturated_into","vzip","PlottingThreadPoolManager","PlottingThreadPoolPair","PlottingThreadPoolsGuard","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","drop","drop","drop","drop","fmt","fmt","fmt","from","from","from","get_thread_pools","init","init","init","into","into","into","new","plotting","replotting","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","unique_saturated_into","unique_saturated_into","unique_saturated_into","vzip","vzip","vzip","AsyncJoinOnDrop","CpuCoreSet","all_cpu_cores","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","cpu_cores","create_plotting_thread_pool_manager","deref","deref","deref_mut","deref_mut","drop","drop","drop","farmer_piece_getter","fmt","from","from","init","init","into","into","into_future","new","parse_cpu_cores_sets","piece_validator","pin_current_thread","poll","rayon_custom_spawn_handler","readers_and_pieces","recommended_number_of_farming_threads","run_future_in_dedicated_thread","ss58","thread_pool_core_indices","to_owned","tokio_rayon_spawn_handler","truncate","try_from","try_from","try_into","try_into","try_poll","type_id","type_id","unique_saturated_into","unique_saturated_into","vzip","vzip","FarmerPieceGetter","borrow","borrow_mut","deref","deref_mut","drop","from","get_piece","init","into","new","try_from","try_into","type_id","unique_saturated_into","vzip","SegmentCommitmentPieceValidator","borrow","borrow_mut","clone","clone_into","deref","deref_mut","drop","from","init","into","new","to_owned","try_from","try_into","type_id","unique_saturated_into","validate_piece","vzip","ReadersAndPieces","add_sector","borrow","borrow_mut","contains_piece","delete_sector","deref","deref_mut","drop","fmt","from","init","into","new","piece_indices","read_piece","try_from","try_into","type_id","unique_saturated_into","vzip","BadBase58","BadLength","FormatNotAllowed","InvalidChecksum","InvalidPrefix","Ss58ParsingError","borrow","borrow_mut","deref","deref_mut","drop","fmt","fmt","from","init","into","parse_ss58_reward_address","to_string","try_from","try_into","type_id","unique_saturated_into","vzip"],"q":[[0,"subspace_farmer"],[66,"subspace_farmer::node_client"],[80,"subspace_farmer::piece_cache"],[119,"subspace_farmer::reward_signing"],[120,"subspace_farmer::single_disk_farm"],[488,"subspace_farmer::single_disk_farm::BackgroundTaskError"],[489,"subspace_farmer::single_disk_farm::PlottingError"],[493,"subspace_farmer::single_disk_farm::SectorExpirationDetails"],[494,"subspace_farmer::single_disk_farm::SectorPlottingDetails"],[500,"subspace_farmer::single_disk_farm::SingleDiskFarmError"],[515,"subspace_farmer::single_disk_farm::SingleDiskFarmInfo"],[520,"subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"],[547,"subspace_farmer::single_disk_farm::SingleDiskFarmSummary"],[552,"subspace_farmer::single_disk_farm::farming"],[768,"subspace_farmer::single_disk_farm::farming::FarmingError"],[770,"subspace_farmer::single_disk_farm::farming::rayon_files"],[787,"subspace_farmer::single_disk_farm::piece_cache"],[849,"subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"],[851,"subspace_farmer::single_disk_farm::piece_reader"],[870,"subspace_farmer::thread_pool_manager"],[924,"subspace_farmer::utils"],[976,"subspace_farmer::utils::farmer_piece_getter"],[992,"subspace_farmer::utils::piece_validator"],[1011,"subspace_farmer::utils::readers_and_pieces"],[1032,"subspace_farmer::utils::ss58"],[1055,"subspace_core_primitives::segments"],[1056,"core::future::future"],[1057,"alloc::boxed"],[1058,"core::pin"],[1059,"core::result"],[1060,"std::path"],[1061,"core::convert"],[1062,"core::fmt"],[1063,"core::fmt"],[1064,"core::option"],[1065,"subspace_core_primitives::pieces"],[1066,"schnorrkel::keys"],[1067,"schnorrkel::keys"],[1068,"schnorrkel::sign"],[1069,"subspace_rpc_primitives"],[1070,"subspace_rpc_primitives"],[1071,"core::fmt"],[1072,"subspace_core_primitives::pieces"],[1073,"core::ops::function"],[1074,"alloc::sync"],[1075,"event_listener_primitives::handler_id"],[1076,"libp2p_kad::record"],[1077,"subspace_farmer_components::plotting"],[1078,"core::error"],[1079,"core::cmp"],[1080,"std::path"],[1081,"parity_scale_codec::codec"],[1082,"serde::de"],[1083,"parity_scale_codec::codec"],[1084,"subspace_farmer_components::plotting"],[1085,"ulid"],[1086,"core::hash"],[1087,"std::io::error"],[1088,"core::marker"],[1089,"subspace_farmer_components::plotting"],[1090,"subspace_farmer_components::sector"],[1091,"anyhow"],[1092,"serde::ser"],[1093,"alloc::string"],[1094,"subspace_core_primitives"],[1095,"subspace_farmer_components::proving"],[1096,"subspace_farmer_components"],[1097,"subspace_proof_of_space"],[1098,"rayon_core"],[1099,"subspace_core_primitives::pieces"],[1100,"core::ops::function"],[1101,"tokio::runtime::task::join"],[1102,"core::num::error"],[1103,"core::task::wake"],[1104,"core::task::poll"],[1105,"rayon_core::registry"],[1106,"core::ops::function"],[1107,"subspace_networking::utils::piece_provider"],[1108,"subspace_networking::node"],[1109,"subspace_core_primitives::crypto::kzg"],[1110,"subspace_core_primitives::segments"]],"d":["Identity struct is an abstraction of public & secret key …","Size of the LRU cache for peers.","","WsClient wrapper.","","","","","","","","","","","Creates new identity, overrides identity that might …","","","","","","","","Returns entropy used to generate keypair.","","Size of the identity file on disk","","Returns the argument unchanged.","Returns the argument unchanged.","","","Calls U::from(self).","Calls U::from(self).","","","Create a new instance of NodeClient.","","Opens the existing identity, returns Ok(None) if it doesn…","Opens the existing identity, or creates a new one.","","","Returns the public key of the identity.","","Returns the secret key of the identity.","","Sign reward hash.","","Submit a block signature","","","","","","","","","","","","","","","","","","","","To become error type agnostic","Abstraction of the Node Client","Node Client extension methods that are not necessary for …","Acknowledge segment header.","Get farmer app info","Get the last segment headers.","Get piece by index.","Get segment headers for the segments","Submit a block signature","Submit a slot solution","Subscribe to archived segment headers","Subscribe to node sync status change","Subscribe to block signing request","Subscribe to slot","Cache worker used to drive the cache","Piece cache that aggregates caches of multiple disks","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Get piece from cache","","","Calls U::from(self).","Calls U::from(self).","Create new piece cache instance and corresponding worker.","Subscribe to cache sync notifications","","Initialize replacement of backing caches, returns …","Run the cache worker with provided piece getter","","","","","","","","","","","","","Sector will expire at the next segment index and should be …","Background downloading panicked","Errors that happen in background tasks","Background task panicked","Cache can’t be opened","Cache file does not exist","Can’t preallocate metadata file, probably not enough …","Can’t preallocate plot file, probably not enough space …","Sector expiration became known","Downloaded sector pieces","Downloading sector pieces","Encoded sector pieces","Encoding sector pieces","Failed to open farm","Sector expiration information updated","Sector already expired","Failed to decode metadata header","Failed to decode metadata header","Failed to determine file size","Failed to retrieve farmer info","Failed to get segment header","Failed to open or create identity","Failed to read bytes from file","Failed to subscribe to archived segments","Failed to write bytes from file","Farm info can’t be opened","Farm info file does not exist","Farm is shutting down","Farm is too large","Farming error","","Finished plotting","Farm was found and read successfully","Identity can’t be opened","Identity file does not exist","Public key in identity doesn’t match metadata","Allocated space is not enough for one sector","Invalid number pieces in sector","I/O error occurred","I/O error occurred","Farm is likely already in use, make sure no other farmer …","Farm is likely already in use, make sure no other farmer …","Low-level plotting error","","Metadata can’t be opened","Metadata file does not exist","Metadata file too small","Missing archived segment header","Farm was not found","","Piece cache error","Plotting error","Sector is being plotted","Errors that happen during plotting","Identity public key doesn’t match public key in the disk …","Reward signing","Details about sector expiration","Details about sector currently being plotted","Various sector updates","Single disk farm abstraction is a container for everything …","Errors happening when trying to create/open single disk …","An identifier for single disk farm, can be used for in …","Important information about the contents of the …","Exclusive lock for single disk farm info file, ensuring no …","Options used to open single disk farm","Errors happening during scrubbing","Summary of single disk farm for presentational purposes","Starting plotting of a sector","Farm ID","Unexpected metadata version","Unexpected metadata version","V0 of the info","Writing sector","Written sector","Wrong chain (genesis hash)","How much space in bytes is allocated for this farm","How much space in bytes was allocated","","","","","","","","","","","","","","","","","","","","","","","","","","","Percentage of allocated space dedicated for caching …","","","","","","","","","","","","Collect summary of single disk farm for presentational …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Path to directory where farm is stored.","Semaphore for part of the plotting when farmer downloads …","","","","","","","","","","","","","","","","","","","","","","Erasure coding instance to use.","Whether to farm during initial plotting","Information necessary for farmer application","","Thread pool size used for farming (mostly for blocking …","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","","","","Returns the argument unchanged.","","","ID of this farm","","Info of this farm","","","","","","","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Kzg instance to use.","Load SingleDiskFarm from path is supposed to be stored, …","How many pieces one sector is supposed to contain (max)","Create new single disk farm instance","Creates new ID","","RPC client connected to Subspace node","Subscribe to farming notifications","Subscribe to sector updates","Subscribe to new solution notification","","","Get piece cache instance","Piece receiver implementation for plotting purposes.","","Get piece reader to read plotted pieces later","How many pieces does one sector contain.","Read information about sectors plotted so far","Number of sectors successfully plotted so far","Notification for plotter to start, can be used to delay …","Thread pool manager used for plotting","","Read all sectors metadata","Address where farming rewards should go","Run and wait for background threads to exit or return an …","Check the farm for corruption and repair errors (caused by …","","","","","","","","","Store SingleDiskFarm info to path so it can be loaded …","","","","","","","","","","","","","","Number of sectors in this farm","","","","","","","","","","","","","","","","","","","","","","","","","","","Try to acquire exclusive lock on the single disk farm info …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Wipe everything that belongs to this single disk farm","","Lower-level error","Lower-level error","Lower-level error","Segment index that was missing","Segment index at which sector expires","Whether this is the last sector queued so far","Information about old plotted sector that was replaced","Information about plotted sector","Progress so far in % (not including this sector)","Whether sector is being replotted","How much time it took to plot a sector","","Current allocated space","","Hex-encoded genesis hash during farm creation","Public key used during farm creation","Farm ID","Farm ID","Farm ID","Number of pieces in sector farm is initialized with","","","Max supported pieces in sector","Minimal allocated space","Hex-encoded current genesis hash","Current public key","How much space in bytes is allocated for this farm","Genesis hash of the chain used for farm creation","ID of the farm","How many pieces does one sector contain.","Public key of identity used for farm creation","Low-level error","Low-level error","Low-level error","Low-level error","Low-level error","Low-level error","Low-level error","Affected file","Affected file","Affected file","Info file","Info file","Identity file","Identity file","Metadata file","Metadata file","Metadata file","Cache file","Cache file","Identity public key","Disk farm info public key","Offset in the file","Offset in the file","Reserved size","Number of bytes to read","Number of bytes to read","File size","Path to directory where farm is stored.","Path to directory where farm is stored.","Path to directory where farm is stored.","Error itself","Farm info","Auditing","Auditing details","Decoded farming error","Special decoded farming error","Failed to create thread pool","Failed to retrieve farmer info","Failed to subscribe to slot info notifications","Errors that happen during farming","Various farming notifications","I/O error occurred","Low-level auditing error","Low-level proving error","Non-fatal farming error","Plot auditing implementation","Plot audit options","Proving","Proving details","Result of the proving","Managed to prove within time limit, but node rejected …","Proved successfully and accepted by the node","Proving took too long","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Erasure coding instance","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","Returns the argument unchanged.","","Returns the argument unchanged.","","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Whether this error is fatal and makes farm unusable","Kzg instance","Optional sector that is currently being modified (for …","Create new instance","Public key of the farm","","Whether proving ended up being successful","Reward address to use for solutions","Number of sectors that were audited","Metadata of all sectors plotted so far","","","","","","Slot info for the audit","","String variant of the error, primarily for monitoring …","Proof of space table generator","Audit duration","Audit duration","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Lower-level error","Lower-level error","Wrapper data structure for multiple files to be used with …","","","","","","Returns the argument unchanged.","","Calls U::from(self).","Open file at specified as many times as there is number of …","","","","","","","","Can’t preallocate cache file, probably not enough space …","Checksum mismatch","Piece cache stored on one disk","Disk piece cache open error","I/O error occurred","Offset wrapper for pieces in DiskPieceCache","Offset outsize of range","Cache size has zero capacity, this is not supported","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","","","","","","","","","","","","","","","","","","","","","Max offset","Provided offset","Wrapper data structure that can be used to read pieces …","","","","","","","","","Returns the argument unchanged.","","Calls U::from(self).","Read piece from sector by offset, None means input …","","","","","","","Plotting thread pool manager.","A wrapper around thread pool pair for plotting purposes","Wrapper around PlottingThreadPoolPair that on Drop will …","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Get one of inner thread pool pairs, will block until one …","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Create new thread pool manager by instantiating …","","","","","","","","","","","","","","","","","","","Joins async join handle on drop","Abstraction for CPU core set","Get all cpu cores, grouped into sets according to NUMA …","","","","","","","","Creates thread pool pairs for each of CPU core set pair …","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Calls U::from(self).","Calls U::from(self).","","Create new instance.","Parse space-separated set of groups of CPU cores …","","Pin current thread to this NUMA node (not just one CPU …","","This function is supposed to be used with …","","Recommended number of thread pool size for farming, equal …","Runs future on a dedicated thread with the specified name, …","Modified version of SS58 parser extracted from Substrate …","Thread indices for each thread pool","","This function is supposed to be used with …","Will truncate list of CPU cores to this number.","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","","","Calls U::from(self).","","","","","","","","","","","","","","","Returns the argument unchanged.","","Calls U::from(self).","","","","","","","","","Wrapper data structure for pieces plotted under multiple …","","","","Check if piece is known and can be retrieved","","","","","","Returns the argument unchanged.","","Calls U::from(self).","","","Read piece from one of the associated readers.","","","","","","Base 58 requirement is violated","Length is bad","Disallowed SS58 Address Format for this datatype","Invalid checksum","Invalid SS58 prefix byte","An error type for SS58 decoding.","","","","","","","","Returns the argument unchanged.","","Calls U::from(self).","Some if the string is a properly encoded SS58Check address.","","","","","",""],"i":[0,0,0,0,0,1,6,1,6,1,6,1,6,1,6,6,6,1,6,1,6,1,6,1,6,1,6,1,6,1,6,1,0,1,1,0,6,6,1,0,6,0,6,1,6,0,1,1,1,1,1,1,0,6,1,6,1,6,1,6,1,6,1,0,6,1,0,0,0,28,28,29,28,28,28,28,28,28,28,28,0,0,31,30,31,30,30,30,31,30,31,30,31,30,31,30,31,30,30,31,30,31,30,30,30,30,30,31,30,31,30,31,30,31,30,31,30,31,30,0,48,62,0,65,64,64,63,63,48,47,47,47,47,53,50,48,63,64,64,62,62,63,64,62,64,64,64,62,63,65,0,47,53,64,64,63,63,63,62,63,63,64,62,58,64,64,64,62,53,58,63,65,50,0,64,65,0,0,0,0,0,0,0,0,0,0,0,47,49,63,64,46,47,47,63,46,74,89,74,58,47,48,62,49,46,53,63,64,65,50,89,74,58,47,48,62,49,46,53,63,64,65,50,74,47,48,49,46,50,47,48,49,46,50,49,58,49,47,48,50,47,48,50,47,48,50,47,48,50,89,74,58,47,48,62,49,46,53,63,64,65,50,89,74,58,47,48,62,49,46,53,63,64,65,50,49,46,74,74,89,74,58,58,47,48,62,49,46,53,63,64,65,50,47,48,50,49,49,49,49,74,74,74,0,74,47,48,62,62,49,49,46,53,63,63,64,64,65,65,50,89,74,58,47,48,62,62,62,49,49,46,53,63,63,63,64,65,65,65,65,50,46,49,58,46,58,89,74,58,47,48,62,49,46,53,63,64,65,50,89,74,58,47,48,62,49,46,53,63,64,65,50,74,46,74,58,49,46,74,58,58,58,49,0,58,74,0,58,46,58,58,74,74,46,58,74,58,58,49,46,47,48,50,62,63,65,46,47,48,50,47,48,49,46,50,62,49,63,64,65,58,89,74,58,47,48,62,49,46,53,63,64,65,50,89,74,58,47,48,62,49,46,53,63,64,65,50,46,89,74,58,47,48,62,49,46,53,63,64,65,50,89,74,58,47,48,62,49,46,53,63,64,65,50,89,74,58,47,48,62,49,46,53,63,64,65,50,58,134,135,136,137,138,139,140,141,141,140,140,141,142,143,142,144,145,144,145,146,146,142,142,146,143,144,145,147,147,147,147,147,148,149,150,151,152,153,154,148,149,150,155,151,156,152,157,153,158,159,154,160,160,149,150,158,149,150,158,161,162,163,163,161,101,0,70,0,70,70,70,0,0,70,70,70,101,0,0,101,0,0,99,99,99,90,90,98,99,100,101,102,70,91,90,98,99,100,101,102,70,91,98,99,100,101,91,98,99,100,101,91,98,99,100,101,102,70,98,99,100,101,102,70,98,99,100,101,102,70,98,99,100,101,102,70,90,98,99,100,101,102,70,91,90,98,99,100,101,102,70,91,90,98,99,100,101,102,70,91,98,99,100,101,102,70,91,98,99,99,100,101,102,102,70,70,91,90,98,99,100,101,102,70,70,70,70,70,91,90,98,99,100,101,102,70,91,90,98,99,100,101,102,70,91,70,91,91,90,91,0,100,91,98,91,98,99,100,101,102,91,70,70,91,98,100,98,99,100,101,102,70,98,99,100,101,91,99,102,70,90,98,99,100,101,102,70,91,90,98,99,100,101,102,70,91,90,98,99,100,101,102,70,91,90,98,99,100,101,102,70,91,90,98,99,100,101,102,70,91,164,165,0,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,104,69,69,0,0,69,0,69,69,69,105,41,69,105,41,105,41,105,41,69,105,41,69,105,41,69,105,41,69,69,105,105,41,69,69,105,41,69,105,41,69,105,41,69,105,41,69,105,69,105,41,69,105,41,69,105,41,69,105,41,69,105,41,166,166,0,80,80,80,80,80,80,80,80,80,80,80,80,80,80,80,80,80,80,0,0,0,109,108,107,109,108,107,107,107,109,108,108,107,109,108,107,109,108,108,107,109,108,107,109,108,107,107,109,108,107,109,108,107,107,109,109,107,109,108,107,109,108,107,109,108,107,109,108,107,109,108,107,0,0,0,114,112,114,112,112,112,112,0,114,112,114,112,114,114,112,0,112,114,112,114,112,114,112,114,114,0,0,112,114,0,0,0,0,0,0,112,0,112,114,112,114,112,114,114,112,114,112,114,112,0,122,122,122,122,122,122,122,122,122,122,122,122,122,122,122,0,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,128,0,126,126,126,126,126,126,126,126,126,126,126,126,126,126,126,126,126,126,126,126,133,133,133,133,133,0,133,133,133,133,133,133,133,133,133,133,0,133,133,133,133,133,133],"f":"`````{{bd}{{j{{h{f}}}}}}{ce{}{}}000{ll}{bb}{{ce}n{}{}}0{c{{A`{l`}}}{{Ad{Ab}}}}{Afc{}}{lc{}}111{Afn}0{l{{Aj{Ah}}}}{b{{j{{h{f}}}}}}{{}Af}{{bAl}An}{cc{}}022<<`{{bB`}{{j{{h{f}}}}}}{Bb{{A`{bBd}}}}`{c{{A`{{Bf{l}}`}}}{{Ad{Ab}}}};{{bBh}{{j{{h{f}}}}}}`{lBj}`{lBl}{{b{Bn{d}}}{{j{{h{f}}}}}}{{l{Aj{Ah}}}C`}`{{bCb}{{j{{h{f}}}}}}{{bCd}{{j{{h{f}}}}}}====`{ce{}{}}0{c{{A`{e}}}{}{}}000{cCf{}}022`22```{{Chd}{{j{{h{f}}}}}}{Ch{{j{{h{f}}}}}}{{CjB`}{{j{{h{f}}}}}}{{ChBh}{{j{{h{f}}}}}}{{Ch{Bn{d}}}{{j{{h{f}}}}}}{{ChCb}{{j{{h{f}}}}}}{{ChCd}{{j{{h{f}}}}}}5555``9999{ClCl}{{ce}n{}{}}{Afc{}}000{Afn}0{{{Cn{c}}Al}An{D`D`}}{{ClAl}An}{cc{}}0{{ClDb}{{Bf{Dd}}}}{{}Af}0{ce{}{}}0{{cDf}{{Dh{Cl{Cn{c}}}}}Ch}{{Cl{Dl{Dj}}}Dn}{{ClDb}{{Bf{E`}}}}{{Cl{Bn{Eb}}}{{Ed{n}}}}{{{Cn{c}}e}nChEf}5{c{{A`{e}}}{}{}}000{cCf{}}07777{{cl}{{A`{{`{{f{}{{Eh{n}}}}}}{h{Ej}}}}}Ch}```````````````````````````````````````````````````````````````````````````{ElB`}`99999999999999999999999999`{EnEn}{F`F`}{FbFb}{ElEl}{FdFd}{{ce}n{}{}}0000{{FbFb}Ff}{FhFj}{{ce}Ff{}{}}{c{{A`{EnFl}}}Fn}{c{{A`{F`Fl}}}Fn}{c{{A`{FdFl}}}Fn}{{{Aj{Ah}}}{{A`{cFl}}}{}}00{{G`{Aj{Ah}}}{{A`{cFl}}}{}}00{{G`c}{{A`{eFl}}}Fn{}}00{Afc{}}0000000000000000000000000{c{{A`{Fb}}}Gb}{c{{A`{El}}}Gb}``{Afn}00{Gdn}1111111111{{Enc}n{GfGh}}{{F`c}n{GfGh}}{{Fdc}n{GfGh}}{{FbFb}Gj}{{ce}Gj{}{}}00`````{{EnAl}An}{{F`Al}An}{{GlAl}An}0{{FbAl}An}0{{ElAl}An}{{FjAl}An}{{GnAl}An}0{{H`Al}An}0{{HbAl}An}0{{FdAl}An}{cc{}}0000{HdGl}{HfGl}2{HhFb}333{HjGn}4{HfGn}55{GlHb}{{{h{Ej}}}Hb}{HlHb}8{El{{Hn{Ah}}}}{{Fbc}nI`}{GdFb}{ElFb}{GdEl}{{}Af}000000000000{ce{}{}}000000000000`{Ab{{Ib{{Bf{El}}}}}}`{{{Id{ce}}Af}{{A`{GdGn}}}Ch{EfIfIhIj}}{{}Fb}{{Fb{Hn{Ah}}IlInB`}El}`{{Gd{Dl{Dj}}}Dn}00{{FbFb}{{Bf{Ff}}}}`{GdEb}``{GdJ`}{ElIn}{Gd{{`{{Jf{}{{Jb{{A`{JdFl}}}}}}}}}}{GdAf}``{ElIl}{Ab{{Ib{{Bn{Jh}}}}}}`{Gd{{Jj{Fb}}}}{Ab{{A`{nH`}}}}{{Fbc}A`Jl}{{Elc}A`Jl}{EnAf}{F`Af}{FdAf}{Gl{{Bf{Ej}}}}{Gn{{Bf{Ej}}}}{Hb{{Bf{Ej}}}}{{ElAb}{{Ib{n}}}}{{c{Aj{Ah}}}{{Bn{Ah}}}{}}00{ce{}{}}0000{cJn{}}0000{GdK`}{c{{A`{e}}}{}{}}0000000000000000000000000{Ab{{Ib{Kb}}}}{cCf{}}00000000000055555555555555555555555555{Ab{{Ib{n}}}}`````````````````````````````````````````````````````````````````````````````````````{{{Kd{c}}{Kf{e}}}{{A`{{Bn{{Dh{K`{`{{Kl{}{{Jb{{A`{{Kh{IlIl}}Kj}}}}}}}}}}}}Kn}}}L`Lb}7777777777777777{LdLd}{LfLf}{LhLh}{LjLj}{{{Kf{c}}}{{Kf{c}}}Lb}{{ce}n{}{}}0000{c{{A`{LdFl}}}Fn}{c{{A`{LfFl}}}Fn}{c{{A`{LhFl}}}Fn}{c{{A`{LjFl}}}Fn}{c{{A`{LlFl}}}Fn}{c{{A`{HlFl}}}Fn}{{{Aj{Ah}}}{{A`{cFl}}}{}}00000{{G`{Aj{Ah}}}{{A`{cFl}}}{}}00000{{G`c}{{A`{eFl}}}Fn{}}00000{Afc{}}000000000000000{Afn}0000000{{Ldc}n{GfGh}}{{Lfc}n{GfGh}}{{Lhc}n{GfGh}}{{Ljc}n{GfGh}}{{Llc}n{GfGh}}{{Hlc}n{GfGh}}`{{LdAl}An}{{LfAl}An}0{{LhAl}An}{{LjAl}An}{{LlAl}An}0{{HlAl}An}0{{{Kf{c}}Al}An{LbD`}}{cc{}}00000{KjHl}{KnHl}{HfHl}3{LnHl}4{{}Af}0000000{ce{}{}}0000000{HlGj}``{c{{Kd{c}}}L`}``````{LdAf}{LfAf}{LhAf}{LjAf}{LlAf}`{Hl{{Bf{Ej}}}}{HlBb}```{{c{Aj{Ah}}}{{Bn{Ah}}}{}}00000:::::{cJn{}}00{c{{A`{e}}}{}{}}000000000000000{cCf{}}0000000================```=={Afc{}}0{Afn}{cc{}}{{}Af}{ce{}{}}{Ab{{Ib{M`}}}}{{M`{Aj{Ah}}Af}{{Ib{n}}}}088722````````222222{MbMb}{EbEb}{{ce}n{}{}}0999999888{{HjAl}An}0{{MbAl}An}0{{EbAl}An}:{HfHj};;:::999{Hj{{Bf{Ej}}}}::{cJn{}}0{c{{A`{e}}}{}{}}00000{cCf{}}00======```=={J`J`}9{Afc{}}0{Afn}{{J`Al}An}{cc{}}{{}Af}{ce{}{}}{{J`K`Md}{{Bf{Dd}}}}199811```111111{MfMf}{{ce}n{}{}}8{Mhc{}}9999988{Mhn}9{{MjAl}An}{{MhAl}An}{{MfAl}An}:::{MfMh}:::999{{cMl}{{A`{MfLn}}}{{Mn{Af}{{Eh{{A`{MjLn}}}}}}}}``:{c{{A`{e}}}{}{}}00000{cCf{}}00<<<<<<``{{}{{Bn{N`}}}}===={N`N`};{N`{{Aj{Af}}}}{c{{A`{MfLn}}}{{Nb{}{{Jb{{Dh{N`N`}}}}}}}}{Afc{}}000{Afn}{{{Nd{c}}}n{}}1`{{N`Al}An}{cc{}}0{{}Af}0{ce{}{}}0{c{}{}}{{{Nf{c}}Gj}{{Nd{c}}}{}}{Bb{{A`{{Bn{N`}}Nh}}}}`{N`n}{{{j{{Nd{c}}}}Nj}{{Nl{e}}}{}{}}{g{{`{{Mn{Nn}{{Eh{{Ib{n}}}}}}}}}Ih{{O`{}{{Eh{c}}}}Ih}{{Mn{Nn}{{Eh{e}}}}If}}`7{{gJn}{{Ib{{`{{f{}{{Eh{{A`{cOb}}}}}}Ih}}}}}Ih{{f{}{{Eh{c}}}}}{{O`{}{{Eh{e}}}}Ih}}`{{{Bf{Ml}}{Bf{Ml}}}{{Bn{N`}}}}8{{}{{`{{Mn{Nn}{{Eh{{Ib{n}}}}}}}}}}{{N`Af}n}{c{{A`{e}}}{}{}}000{{{j{c}}Nj}Nl{}}{cCf{}}0====`=={Afc{}}0{Afn}{cc{}}{{{Od{ce}}BhOf}{{j{{h{f}}}}}{OhIh}Ch}{{}Af}{ce{}{}}{{{Oj{c}}Cle{Dl{{On{{Bf{Ol}}}}}}}{{Od{ce}}}{}{}}99711`11{{{A`{c}}}{{A`{c}}}If}{{ce}n{}{}}887643{{AbcAd{Dl{{On{{Ah{dAf}}}}}}}{{A`{c}}}{}}4<<:4{{{A`{c}}DfBhDd}{{j{{h{f}}}}}Ch}5`{{OlAhJd}n}66{{OlBh}Gj}1<<;{{OlAl}An};98{{{Bn{J`}}}Ol}{Ol{{`{{Jf{}{{Jb{Bh}}}}}}}}{{OlBh}{{Bf{{`{{f{}{{Eh{{Bf{Dd}}}}}}}}}}}}{c{{A`{e}}}{}{}}0{cCf{}}==``````=={Afc{}}0{Afn}{{AjAl}An}0{cc{}}{{}Af}{ce{}{}}{Bb{{A`{IlAj}}}}{cJn{}}99822","c":[],"p":[[5,"NodeRpcClient",0],[5,"SegmentIndex",1055],[10,"Future",1056],[5,"Box",1057],[5,"Pin",1058],[5,"Identity",0],[1,"unit"],[6,"Result",1059],[5,"Path",1060],[10,"AsRef",1061],[1,"usize"],[1,"u8"],[1,"slice"],[5,"Formatter",1062],[8,"Result",1062],[1,"u64"],[1,"str"],[6,"Error",1063],[6,"Option",1064],[5,"PieceIndex",1065],[5,"PublicKey",1066],[5,"SecretKey",1066],[5,"Vec",1067],[5,"Signature",1068],[5,"RewardSignatureResponse",1069],[5,"SolutionResponse",1069],[5,"TypeId",1070],[10,"NodeClient",66],[10,"NodeClientExt",66],[5,"PieceCache",80],[5,"CacheWorker",80],[10,"Debug",1062],[5,"Key",1071],[5,"Piece",1065],[5,"PeerId",1072],[1,"tuple"],[10,"Fn",1073],[5,"Arc",1074],[5,"HandlerId",1075],[5,"ProviderRecord",1071],[5,"DiskPieceCache",787],[5,"Receiver",1076],[10,"PieceGetter",1077],[17,"Output"],[10,"Error",1078],[6,"SingleDiskFarmInfo",120],[6,"SectorPlottingDetails",120],[6,"SectorExpirationDetails",120],[6,"SingleDiskFarmId",120],[6,"SectorUpdate",120],[6,"Ordering",1079],[5,"PathBuf",1060],[6,"SingleDiskFarmSummary",120],[5,"Error",1080],[10,"Input",1081],[1,"u32"],[10,"Deserializer",1082],[5,"SingleDiskFarm",120],[10,"Output",1081],[10,"Sized",1083],[1,"bool"],[6,"PlottingError",120],[6,"SingleDiskFarmError",120],[6,"SingleDiskFarmScrubError",120],[6,"BackgroundTaskError",120],[6,"PlottingError",1077],[5,"Error",1084],[5,"Ulid",1085],[6,"DiskPieceCacheError",787],[6,"FarmingError",552],[1,"array"],[10,"Hasher",1086],[8,"Result",1084],[5,"SingleDiskFarmOptions",120],[10,"Clone",1087],[10,"Send",1083],[10,"Sync",1083],[5,"PublicKey",1088],[1,"u16"],[5,"PieceReader",851],[17,"Item"],[5,"PlottedSector",1077],[10,"Iterator",1089],[5,"SectorMetadataChecksummed",1090],[8,"Result",1091],[10,"Serializer",1092],[5,"String",1093],[8,"SectorIndex",1088],[5,"SingleDiskFarmInfoLock",120],[5,"PlotAudit",552],[5,"PlotAuditOptions",552],[5,"Solution",1088],[6,"ProvingError",1094],[10,"ProvableSolutions",1094],[6,"AuditingError",1095],[10,"ReadAtSync",1096],[10,"Table",1097],[5,"AuditingDetails",552],[6,"ProvingResult",552],[5,"ProvingDetails",552],[6,"FarmingNotification",552],[5,"DecodedFarmingError",552],[5,"ThreadPoolBuildError",1098],[5,"RayonFiles",770],[5,"Offset",787],[5,"PieceOffset",1065],[5,"PlottingThreadPoolManager",870],[5,"PlottingThreadPoolsGuard",870],[5,"PlottingThreadPoolPair",870],[5,"NonZeroUsize",1099],[10,"FnMut",1073],[5,"CpuCoreSet",924],[10,"ExactSizeIterator",1100],[5,"AsyncJoinOnDrop",924],[5,"JoinHandle",1101],[5,"ParseIntError",1102],[5,"Context",1103],[6,"Poll",1104],[5,"ThreadBuilder",1105],[10,"FnOnce",1073],[5,"Canceled",1076],[5,"FarmerPieceGetter",976],[6,"PieceGetterRetryPolicy",1077],[10,"PieceValidator",1106],[5,"PieceProvider",1106],[5,"ReadersAndPieces",1011],[8,"Mutex",1107],[5,"SegmentCommitmentPieceValidator",992],[5,"Node",1108],[5,"Kzg",1109],[5,"SegmentCommitment",1055],[5,"LruCache",1110],[6,"Ss58ParsingError",1032],[15,"BackgroundTaskPanicked",488],[15,"FailedToGetFarmerInfo",489],[15,"FailedToGetSegmentHeader",489],[15,"FailedToSubscribeArchivedSegments",489],[15,"MissingArchivedSegmentHeader",489],[15,"Determined",493],[15,"Starting",494],[15,"Finished",494],[15,"FarmTooLarge",500],[15,"InsufficientAllocatedSpace",500],[15,"WrongChain",500],[15,"IdentityMismatch",500],[15,"InvalidPiecesInSector",500],[15,"V0",515],[15,"FailedToDetermineFileSize",520],[15,"FailedToReadBytes",520],[15,"FailedToWriteBytes",520],[15,"FarmInfoCantBeOpened",520],[15,"IdentityCantBeOpened",520],[15,"MetadataCantBeOpened",520],[15,"CacheCantBeOpened",520],[15,"FarmInfoFileDoesNotExist",520],[15,"IdentityFileDoesNotExist",520],[15,"MetadataFileDoesNotExist",520],[15,"MetadataFileTooSmall",520],[15,"CacheFileDoesNotExist",520],[15,"PublicKeyMismatch",520],[15,"Found",547],[15,"NotFound",547],[15,"Error",547],[15,"FailedToSubscribeSlotInfo",768],[15,"FailedToGetFarmerInfo",768],[15,"OffsetOutsideOfRange",849]],"b":[[307,"impl-Display-for-PlottingError"],[308,"impl-Debug-for-PlottingError"],[309,"impl-Debug-for-SingleDiskFarmId"],[310,"impl-Display-for-SingleDiskFarmId"],[313,"impl-Display-for-SingleDiskFarmError"],[314,"impl-Debug-for-SingleDiskFarmError"],[315,"impl-Display-for-SingleDiskFarmScrubError"],[316,"impl-Debug-for-SingleDiskFarmScrubError"],[317,"impl-Debug-for-BackgroundTaskError"],[318,"impl-Display-for-BackgroundTaskError"],[325,"impl-From%3CPlottingError%3E-for-PlottingError"],[326,"impl-From%3CError%3E-for-PlottingError"],[332,"impl-From%3CDiskPieceCacheError%3E-for-SingleDiskFarmError"],[334,"impl-From%3CError%3E-for-SingleDiskFarmError"],[337,"impl-From%3CPlottingError%3E-for-BackgroundTaskError"],[338,"impl-From%3CBox%3Cdyn+Error+%2B+Send+%2B+Sync%3E%3E-for-BackgroundTaskError"],[339,"impl-From%3CFarmingError%3E-for-BackgroundTaskError"],[656,"impl-Debug-for-ProvingResult"],[657,"impl-Display-for-ProvingResult"],[660,"impl-Debug-for-DecodedFarmingError"],[661,"impl-Display-for-DecodedFarmingError"],[662,"impl-Display-for-FarmingError"],[663,"impl-Debug-for-FarmingError"],[671,"impl-From%3CProvingError%3E-for-FarmingError"],[672,"impl-From%3CAuditingError%3E-for-FarmingError"],[673,"impl-From%3CError%3E-for-FarmingError"],[675,"impl-From%3CThreadPoolBuildError%3E-for-FarmingError"],[780,"impl-ReadAtSync-for-%26RayonFiles"],[781,"impl-ReadAtSync-for-RayonFiles"],[814,"impl-Display-for-DiskPieceCacheError"],[815,"impl-Debug-for-DiskPieceCacheError"],[816,"impl-Display-for-Offset"],[817,"impl-Debug-for-Offset"],[1043,"impl-Display-for-Ss58ParsingError"],[1044,"impl-Debug-for-Ss58ParsingError"]]}],\
 ["subspace_farmer_components",{"doc":"Components of the reference implementation of Subspace …","t":"PFFGKFKPNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNONNNNNNNNNOONNCCMMNNNNCOOCNNNNNNNNNNNNNNNNNNNNNNNNNFGPHHONNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNOOOKKMMMMMMMPPFFFPPPPKGPPFFGPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHONNNNNNNHNONOOOONNNNNNNNNNNNMNNNNNNNNNNNNNNOOOOOOOOOOHOOOOOOOOOOOONNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOPPPPPKGPFMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOPPPPPPFGPNNNNNNONNNNNNNNNNNNNNNNNNHHHHONNNNNNNNNNNNNOOOOOOOOOOOPFPPPPFGGGFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNONNOOHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOO","n":["Async","AsyncReadBytes","FarmerProtocolInfo","ReadAt","ReadAtAsync","ReadAtOffset","ReadAtSync","Sync","as_mut","as_mut_bits","as_mut_byte_slice","as_mut_slice_of","auditing","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deserialize","drop","drop","drop","drop","file_ext","fmt","fmt","from","from","from","from","from","from","from_async","from_sync","history_size","init","init","init","init","into","into","into","into","into_inner","max_pieces_in_sector","min_sector_lifetime","offset","offset","plotting","proving","read_at","read_at","read_at","read_at","read_at","read_at","reading","recent_history_fraction","recent_segments","sector","serialize","to_owned","to_owned","to_owned","try_as_mut_bits","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","vzip","vzip","vzip","vzip","AuditResult","AuditingError","SBucketReading","audit_plot_sync","audit_sector_sync","best_solution_distance","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deref","deref","deref_mut","deref_mut","drop","drop","fmt","fmt","fmt","from","from","init","init","into","into","sector_index","solution_candidates","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","unique_saturated_into","unique_saturated_into","vzip","vzip","error","s_bucket_audit_index","sector_index","FileExt","OpenOptionsExt","advise_random_access","advise_random_access","advise_sequential_access","advise_sequential_access","preallocate","read_exact_at","write_all_at","BadSectorMetadataOutputSize","BadSectorOutputSize","DownloadSectorOptions","DownloadedSector","EncodeSectorOptions","FailedToAcquirePermit","FailedToRetrievePiece","InvalidErasureCodingInstance","Limited","PieceGetter","PieceGetterRetryPolicy","PieceNotFound","PieceRecoveryFailed","PlotSectorOptions","PlottedSector","PlottingError","Unlimited","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","decode","decode_all","decode_all_with_depth_limit","decode_with_depth_limit","default","deref","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","download_sector","downloading_semaphore","drop","drop","drop","drop","drop","drop","drop","encode_sector","encode_to","encoding_semaphore","eq","erasure_coding","erasure_coding","farmer_protocol_info","farmer_protocol_info","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","get_piece","init","init","init","init","init","init","init","into","into","into","into","into","into","into","kzg","kzg","piece_getter","piece_getter","piece_getter_retry_policy","piece_getter_retry_policy","piece_indexes","pieces_in_sector","pieces_in_sector","pieces_in_sector","plot_sector","public_key","public_key","sector_id","sector_index","sector_index","sector_index","sector_index","sector_metadata","sector_metadata_output","sector_metadata_output","sector_output","sector_output","size_hint","source","table_generator","table_generator","to_keyed_vec","to_owned","to_owned","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","vzip","vzip","vzip","vzip","vzip","vzip","vzip","error","error","expected","expected","piece_index","piece_index","piece_index","provided","provided","FailedToCreateChunkWitness","FailedToCreatePolynomialForRecord","FailedToDecodeSectorContentsMap","InvalidErasureCodingInstance","Io","ProvableSolutions","ProvingError","RecordReadingError","SolutionCandidates","best_solution_distance","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deref","deref","deref_mut","deref_mut","drop","drop","fmt","fmt","fmt","from","from","from","from","from","init","init","into","into","into_solutions","is_empty","is_fatal","len","source","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","unique_saturated_into","unique_saturated_into","vzip","vzip","chunk_offset","error","error","piece_offset","piece_offset","ChecksumMismatch","FailedToDecodeSectorContentsMap","FailedToErasureDecodeRecord","FailedToReadChunk","InvalidChunk","Io","PlotRecord","ReadingError","WrongRecordSizeAfterDecoding","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","commitment","deref","deref","deref_mut","deref_mut","drop","drop","fmt","fmt","fmt","from","from","from","from","init","init","into","into","is_fatal","read_piece","read_sector_record_chunks","recover_extended_record_chunks","recover_source_record_chunks","scalars","source","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","unique_saturated_into","unique_saturated_into","vzip","vzip","witness","actual","chunk_location","chunk_location","encoded_chunk_used","error","error","error","expected","piece_offset","s_bucket","ChecksumMismatch","EncodedChunksUsed","InvalidBytesLength","InvalidBytesLength","InvalidEncodedRecordChunks","SBucketOutOfRange","SectorContentsMap","SectorContentsMapEncodeIntoError","SectorContentsMapFromBytesError","SectorContentsMapIterationError","SectorMetadata","SectorMetadataChecksummed","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","decode","decode","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","deref","deref","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","drop","drop","drop","drop","drop","drop","drop","drop","encode","encode_into","encode_to","encode_to","encoded_size","encoded_size","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from_bytes","history_size","init","init","init","init","init","init","init","into","into","into","into","into","into","into","iter","iter_mut","iter_record_bitfields","iter_record_bitfields_mut","iter_record_chunk_to_plot","iter_s_bucket_encoded_record_chunks_used","iter_s_bucket_records","new","num_encoded_record_chunks","par_iter_record_chunk_to_plot","pieces_in_sector","s_bucket_offsets","s_bucket_sizes","s_bucket_sizes","sector_index","sector_record_chunks_size","sector_record_metadata_size","sector_size","size_hint","size_hint","to_keyed_vec","to_keyed_vec","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","using_encoded","vzip","vzip","vzip","vzip","vzip","vzip","vzip","actual","expected","actual","actual","expected","max","max","provided"],"q":[[0,"subspace_farmer_components"],[102,"subspace_farmer_components::auditing"],[143,"subspace_farmer_components::auditing::AuditingError"],[146,"subspace_farmer_components::file_ext"],[155,"subspace_farmer_components::plotting"],[319,"subspace_farmer_components::plotting::PlottingError"],[328,"subspace_farmer_components::proving"],[379,"subspace_farmer_components::proving::ProvingError"],[384,"subspace_farmer_components::reading"],[437,"subspace_farmer_components::reading::ReadingError"],[447,"subspace_farmer_components::sector"],[626,"subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"],[628,"subspace_farmer_components::sector::SectorContentsMapFromBytesError"],[632,"subspace_farmer_components::sector::SectorContentsMapIterationError"],[634,"core::convert"],[635,"core::marker"],[636,"bitvec::slice"],[637,"bitvec::order"],[638,"byte_slice_cast"],[639,"core::result"],[640,"byte_slice_cast"],[641,"serde::de"],[642,"core::fmt"],[643,"core::fmt"],[644,"alloc::boxed"],[645,"std::io::error"],[646,"core::future::future"],[647,"serde::ser"],[648,"bitvec::ptr::span"],[649,"core::any"],[650,"subspace_core_primitives"],[651,"subspace_core_primitives"],[652,"alloc::string"],[653,"parity_scale_codec::error"],[654,"parity_scale_codec::codec"],[655,"subspace_proof_of_space"],[656,"parity_scale_codec::codec"],[657,"subspace_core_primitives::pieces"],[658,"core::pin"],[659,"core::error"],[660,"std::io::error"],[661,"subspace_erasure_coding"],[662,"subspace_core_primitives"],[663,"subspace_core_primitives::pieces"],[664,"core::iter::traits::exact_size"],[665,"core::ops::deref"],[666,"core::ops::deref"],[667,"subspace_core_primitives::pieces"],[668,"rayon::iter"],[669,"core::ops::function"]],"d":["Async variant","Container or asynchronously reading bytes using in …","Information about the protocol necessary for farmer …","Enum to encapsulate the selection between ReadAtSync and […","Async version of ReadAt, it is neither Send nor Sync and …","Reader with fixed offset added to all attempted reads","Sync version of ReadAt, it is both Send and Sync and is …","Sync variant","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","File extension trait","","","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Instantiate ReadAt from some ReadAtAsync implementation","Instantiate ReadAt from some ReadAtSync implementation","Size of the blockchain history","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Extract inner value","How many pieces one sector is supposed to contain (max)","Minimum lifetime of a plotted sector, measured in archived …","Get implementation of ReadAtSync that add specified offset …","Get implementation of ReadAtAsync that add specified …","","","Fill the buffer by reading bytes at a specific offset","Fill the buffer by reading bytes at a specific offset and …","","","","","","Fraction of pieces from the “recent history” (…","Number of latest archived segments that are considered “…","","","","","","","","","","","","","","","","","","","","","","","","","","","Result of sector audit","Errors that happen during proving","Failed read s-bucket","Audit the whole plot and generate streams of solutions","Audit a single sector and generate a stream of solutions.","Best solution distance found","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Calls U::from(self).","Calls U::from(self).","Sector index","Solution candidates","","","","","","","","","","","","","Low-level error","S-bucket audit index","Sector index","Extension convenience trait that allows pre-allocating …","Extension convenience trait that allows setting some file …","Advise OS/file system that file will use random access and …","Advise OS/file system that file will use random access and …","Advise OS/file system that file will use sequential access …","Advise OS/file system that file will use sequential access …","Make sure file has specified number of bytes allocated for …","Read exact number of bytes at a specific offset","Write all provided bytes at a specific offset","Bad sector metadata output size","Bad sector output size","Options for sector downloading","Opaque sector downloaded and ready for encoding","Options for encoding a sector.","Failed to acquire permit","Failed to retrieve piece","Invalid erasure coding instance","Retry N times (including zero)","Duplicate trait for the …","Defines retry policy on error during piece acquiring.","Piece not found, can’t create sector, this should never …","Can’t recover missing piece","Options for plotting a sector.","Information about sector that was plotted","Plotting status","No restrictions on retries","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Download sector for plotting.","Semaphore for part of the plotting when farmer downloads …","","","","","","","","","","Semaphore for part of the plotting when farmer encodes …","","Erasure coding instance","Erasure coding instance","Farmer protocol info","Farmer protocol info","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","KZG instance","KZG instance","Getter for pieces of archival history","Getter for pieces of archival history","Retry policy for piece getter","Retry policy for piece getter","Indexes of pieces that were plotted","How many pieces should sector contain","How many pieces should sector contain","How many pieces should sector contain","Plot a single sector.","Public key corresponding to sector","Public key corresponding to sector","Sector ID","Sector index","Sector index","Sector index","Sector index","Sector metadata","Where plotted sector metadata should be written, vector …","Where plotted sector metadata should be written, vector …","Where plotted sector should be written, vector must either …","Where plotted sector should be written, vector must either …","","","Proof of space table generator","Proof of space table generator","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Lower-level error","Lower-level error","Expected size","Expected size","Piece index","Piece index","Piece index","Actual size","Actual size","Failed to create chunk witness","Failed to create polynomial for record","Failed to decode sector contents map","Invalid erasure coding instance","I/O error occurred","Solutions that can be proven if necessary.","Errors that happen during proving","Record reading error","Container for solution candidates.","Best solution distance found, None in case there are no …","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Calls U::from(self).","Calls U::from(self).","Turn solution candidates into actual solutions","Returns true if no candidates inside","Whether this error is fatal and makes farm unusable","Total number of candidates","","","","","","","","","","","","","","Chunk index","Lower-level error","Lower-level error","Piece offset","Piece offset","Checksum mismatch","Failed to decode sector contents map","Failed to erasure-decode record","Failed to read chunk.","Invalid chunk, possible disk corruption","I/O error occurred","Record contained in the plot","Errors that happen during reading","Wrong record size after decoding","","","","","","","Record commitment","","","","","","","","","","","Returns the argument unchanged.","","Returns the argument unchanged.","","","Calls U::from(self).","Calls U::from(self).","Whether this error is fatal and renders farm unusable","Read piece from sector.","Read sector record chunks, only plotted s-buckets are …","Given sector record chunks recover extended record chunks …","Given sector record chunks recover source record chunks in …","Record scalars","","","","","","","","","","","","","","Record witness","Actual size in bytes","Chunk location","Chunk location","Indicates whether chunk was encoded","Low-level error","Lower-level error","Lower-level error","Expected size in bytes","Piece offset","S-bucket","Checksum mismatch","Wrapper data structure that allows to iterate mutably over …","Invalid bytes length","Invalid bytes length","Invalid number of encoded record chunks","S-bucket provided is out of range","Abstraction on top of bitfields that allow making sense of …","Error happening when trying to encode SectorContentsMap …","Error happening when trying to create SectorContentsMap …","Error happening when trying to create SectorContentsMap …","Metadata of the plotted sector","Same as SectorMetadata, but with checksums verified during …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Encode internal contents into output","","","Size of encoded checksummed sector metadata.","Size of sector contents map when encoded and stored in the …","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Reconstruct sector contents map from bytes.","Size of the blockchain history at time of sector creation","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Produces an iterator over encoded chunks bitfields.","Produces a mutable iterator over encoded chunks bitfields.","Iterate over individual record bitfields","Iterate mutably over individual record bitfields","Creates an iterator of …","Iterate over chunks of s-bucket indicating if encoded …","Creates an iterator of (piece_offset, encoded_chunk_used), …","Create new sector contents map initialized with zeroes to …","Number of encoded chunks in each record","Creates an iterator of …","Number of pieces stored in this sector","Returns offsets of each s-bucket relatively to the …","Returns sizes of each s-bucket","S-bucket sizes in a sector","Sector index","Size of the part of the plot containing record chunks …","Size of the part of the plot containing record metadata.","Exact sector plot size (sector contents map, record …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Actual length","Expected length","Actual length","Actual number of encoded record chunks","Expected length","Max supported","Max s-bucket","Provided s-bucket"],"i":[11,0,0,0,0,0,0,11,1,1,1,1,0,1,11,15,16,1,11,15,16,11,15,16,11,15,16,1,11,15,16,1,11,15,16,16,1,11,15,16,0,15,16,1,1,1,11,15,16,11,11,16,1,11,15,16,1,11,15,16,1,16,16,12,14,0,0,12,14,15,15,15,15,0,16,16,0,16,11,15,16,1,1,11,15,16,1,11,15,16,1,11,15,16,1,11,15,16,1,11,15,16,0,0,39,0,0,38,39,38,39,38,38,38,39,38,39,38,39,38,39,39,38,39,38,39,38,39,38,38,38,38,39,39,38,39,38,39,38,39,38,39,38,98,98,98,0,0,41,42,41,42,42,42,42,51,51,0,0,0,51,51,51,44,0,0,51,51,0,0,0,44,61,50,49,53,44,45,51,61,50,49,53,44,45,51,44,45,44,45,45,45,45,45,44,61,50,49,53,44,45,51,61,50,49,53,44,45,51,0,61,61,50,49,53,44,45,51,0,45,61,44,61,53,61,49,44,45,51,51,61,50,49,53,44,45,51,51,52,61,50,49,53,44,45,51,61,50,49,53,44,45,51,61,49,61,49,61,49,45,61,49,53,0,61,49,45,61,49,53,45,45,61,53,61,53,45,51,61,53,45,44,45,51,61,50,49,53,44,45,51,61,50,49,53,44,45,51,61,50,49,53,44,45,51,61,50,49,53,44,45,51,61,50,49,53,44,45,51,99,100,101,102,103,104,99,101,102,65,65,65,65,65,0,0,65,0,63,65,64,65,64,64,64,65,64,65,64,65,64,65,65,64,65,65,65,65,64,65,64,65,64,64,64,65,64,65,64,65,65,64,65,64,65,64,65,64,65,64,105,106,105,106,105,68,68,68,68,68,68,0,0,68,68,76,68,76,76,76,76,68,76,68,76,68,76,68,68,76,68,68,68,76,68,76,68,76,68,0,0,0,0,76,68,76,68,68,76,68,76,68,76,68,76,68,76,76,107,108,109,109,108,109,110,107,110,109,66,0,66,86,66,87,0,0,0,0,0,0,88,85,35,66,86,87,82,88,85,35,66,86,87,82,85,35,66,86,87,82,85,35,66,86,87,82,85,35,85,35,85,35,85,35,88,85,35,35,66,86,87,82,88,85,35,35,66,86,87,82,88,88,85,35,66,86,87,82,35,82,85,35,35,82,66,86,87,85,35,66,66,86,86,87,87,82,88,85,35,35,66,86,87,82,82,85,88,85,35,66,86,87,82,88,85,35,66,86,87,82,88,88,82,82,82,82,82,82,82,82,85,85,82,85,85,0,0,0,85,35,85,35,85,35,66,86,87,82,66,86,87,88,85,35,66,86,87,82,88,85,35,66,86,87,82,88,85,35,66,86,87,82,88,85,35,66,86,87,82,35,88,85,35,66,86,87,82,111,111,112,113,112,113,114,114],"f":"````````{{{b{c}}}{{f{d}}}{{h{{f{d}}}}j}}{c{{l{eg}}}{}{}n}{c{{f{d}}}{}}{c{{Ab{{f{e}}A`}}}{}Ad}`{ce{}{}}0000000{{{Af{ce}}}{{Af{ce}}}{AhAj}{AlAj}}{{{An{c}}}{{An{c}}}Aj}{B`B`}{{ce}Bb{}{}}00{Bdc{}}0000000{c{{Ab{B`}}}Bf}{BdBb}000`{{{An{c}}Bh}BjBl}{{B`Bh}Bj}{cc{}}{{{Bn{d}}}{{b{{Bn{d}}}}}}{{{C`{{f{d}}}}}{{b{{C`{{f{d}}}}}}}}222{c{{Af{Cbc}}}Al}{c{{Af{cCb}}}Ah}`{{}Bd}000????{{{b{c}}}c{{h{{f{d}}}}j}}``{{AhBd}{{An{Ah}}}}{{AlBd}{{An{Al}}}}``{{Ah{f{d}}Bd}{{Cd{Bb}}}}{{AlcBd}{{`{{Ch{}{{Cf{{Cd{c}}}}}}}}}{{h{{f{d}}}}j}}{{{An{c}}eBd}{{Cd{e}}}Al{{h{{f{d}}}}j}}{{{An{c}}{f{d}}Bd}{{Cd{Bb}}}Ah}10````{{B`c}AbCj}{ce{}{}}00{c{{Ab{{l{eg}}{Cl{e}}}}}{}{}n}{c{{Ab{e}}}{}{}}0000000{cCn{}}00033333333```{{D`DbDdc{f{Df}}{Dj{Dh}}}{{Ab{{Bn{{Dl{{An{c}}}}}}Dn}}}Ah}{{D`DbDdcDf}{{Ab{{Dj{{Dl{c}}}}Dn}}}Ah}`5555{{{Dl{c}}}{{Dl{c}}}Aj}{{ce}Bb{}{}}{Bdc{}}000{BdBb}0{{DnBh}Bj}0{{{Dl{c}}Bh}BjBl}{cc{}}0{{}Bd}0==``={cE`{}}<<<<;;>>>>`````{EbEb}{Ed{{Cd{Bb}}}}10{{EdEf}{{Cd{Bb}}}}{{Ed{f{d}}Ef}{{Cd{Bb}}}}0`````````````````{ce{}{}}0000000000000{EhEh}{EjEj}>>{c{{Ab{EjEl}}}En}{{{f{d}}}{{Ab{cEl}}}{}}{{F`{f{d}}}{{Ab{cEl}}}{}}{{F`c}{{Ab{eEl}}}En{}}{{}Eh}{Bdc{}}0000000000000{{{Fb{c}}}{{Ab{FdFf}}}Fh}`{BdBb}000000{{Fd{Fj{c}}}{{Ab{EjFf}}}Fl}{{Ejc}Bb{FnG`}}`{{EhEh}Gb}````{{EhBh}Bj}{{EjBh}Bj}{{FfBh}Bj}0{cc{}}00000{GdFf}1{{FhGfEh}{{Gh{{C`{Ch}}}}}}{{}Bd}000000{ce{}{}}000000``````````{{{Gj{ce}}}{{Ab{EjFf}}}FlFh}````````````{EjBd}{Ff{{Dj{Gl}}}}``{{c{f{d}}}{{Bn{d}}}{}}44{cE`{}}{c{{Ab{e}}}{}{}}0000000000000{cCn{}}00000077777777777777``````````````````{Gn{{Dj{Dd}}}}8888{{{H`{c}}}{{H`{c}}}Aj}{{ce}Bb{}{}}{Bdc{}}000{BdBb}0{{HbBh}Bj}0{{{H`{c}}Bh}BjBl}{HdHb}{HfHb}{HhHb}{cc{}}0{{}Bd}0{ce{}{}}0{{{H`{c}}eHjHli}{{Ab{{`{{Gn{}{{Hn{{Ab{{I`{D`e}}Hb}}}}}}}}Hb}}}AhIbFl{{If{Id}{{Cf{g}}}}}}{{{H`{c}}}GbAh}{HbGb}{{{H`{c}}}BdAh}{Hb{{Dj{Gl}}}}5{cE`{}}{c{{Ab{e}}}{}{}}000{cCn{}}08888``````````````8888{IhIh}{{ce}Bb{}{}}`{Bdc{}}000{BdBb}0{{HhBh}Bj}0{{IhBh}Bj}{HfHh}{cc{}}{HdHh}1{{}Bd}0{ce{}{}}0{HhGb}{{IjIlDf{Af{ce}}Hl}{{Ab{InHh}}}AhAl}{{IjJ`{Jb{F`}}Jdc{Af{eg}}}{{Ab{{C`{{Jb{{Dj{Jf}}}}}}Hh}}}FlAhAl}{{{Jb{{Dj{Jf}}}}IjHl}{{Ab{{C`{{Jb{Jf}}}}Hh}}}}{{{Jb{{Dj{Jf}}}}IjHl}{{Ab{{`{{Jh{}{{Hn{Jf}}}}}}Hh}}}}`{Hh{{Dj{Gl}}}}6{cE`{}}{c{{Ab{e}}}{}{}}000{cCn{}}09999```````````````````````99999999999999{JjJj}{DfDf}{HdHd}{JlJl}{JnJn}{JdJd}{{ce}Bb{}{}}00000{c{{Ab{JjEl}}}En}{c{{Ab{DfEl}}}En}{{{f{d}}}{{Ab{cEl}}}{}}0{{F`{f{d}}}{{Ab{cEl}}}{}}0{{F`c}{{Ab{eEl}}}En{}}0{Bdc{}}00{Dfc{}}111111011111{K`Bb}{BdBb}000000{Df{{Bn{d}}}}{{Jd{f{d}}}{{Ab{BbJl}}}}{{Jjc}Bb{FnG`}}{{Dfc}Bb{FnG`}}{{}Bd}{J`Bd}{{HdHd}Gb}{{JlJl}Gb}{{JnJn}Gb}{{JjBh}Bj}{{DfBh}Bj}{{HdBh}Bj}0{{JlBh}Bj}0{{JnBh}Bj}0{{JdBh}Bj}{cc{}}0{JjDf}11111{{{f{d}}J`}{{Ab{JdHd}}}}`======={ce{}{}}000000{K`{{`{{Jh{}{{Hn{{`{{Kd{}{{Kb{Gb}}}}}}}}}}}}}}{K`{{`{{Jh{}{{Hn{{`{{Kf{}{{Kb{Gb}}}}}}}}}}}}}}{Jd{{f{{Kh{{Jb{d}}}}}}}}{Jd{{`{{Jh{}{{Hn{K`}}}}}}}}{{JdIj}{{`{{Kn{}{{Hn{{Kl{KjGbBd}}}}}}}}}}{{JdKj}{{Ab{{`{{Kn{}{{Hn{Gb}}}}}}Jn}}}}{{JdKj}{{Ab{{`{{Kn{}{{Hn{{Kl{IjGb}}}}}}}}Jn}}}}{J`Jd}{Jd{{f{Kj}}}}{{JdIj}{{`{{L`{}{{Hn{{Dj{{Kl{BdGb}}}}}}}}}}}}`{Jj{{C`{{Jb{F`}}}}}}{Jd{{C`{{Jb{J`}}}}}}``{J`Bd}00{JjBd}{DfBd}{{c{f{d}}}{{Bn{d}}}{}}0{ce{}{}}00000{cE`{}}00{c{{Ab{e}}}{}{}}0000000000000{cCn{}}0000003333333{{Dfe}c{}{{Lb{{f{d}}}{{Cf{c}}}}}}4444444````````","c":[],"p":[[5,"AsyncReadBytes",0],[1,"u8"],[1,"slice"],[10,"AsMut",634],[10,"Unpin",635],[5,"BitSlice",636],[10,"BitOrder",637],[6,"Error",638],[6,"Result",639],[10,"FromByteSlice",638],[6,"ReadAt",0],[10,"ReadAtSync",0],[10,"Clone",640],[10,"ReadAtAsync",0],[5,"ReadAtOffset",0],[5,"FarmerProtocolInfo",0],[1,"unit"],[1,"usize"],[10,"Deserializer",641],[5,"Formatter",642],[8,"Result",642],[10,"Debug",642],[5,"Vec",643],[5,"Box",644],[1,"never"],[8,"Result",645],[17,"Output"],[10,"Future",646],[10,"Serializer",647],[6,"BitSpanError",648],[5,"TypeId",649],[5,"PublicKey",650],[8,"Blake3Hash",650],[8,"SolutionRange",650],[5,"SectorMetadataChecksummed",447],[8,"SectorIndex",650],[6,"Option",651],[5,"AuditResult",102],[6,"AuditingError",102],[5,"String",652],[10,"OpenOptionsExt",146],[10,"FileExt",146],[1,"u64"],[6,"PieceGetterRetryPolicy",155],[5,"PlottedSector",155],[5,"Error",653],[10,"Input",654],[1,"u32"],[5,"DownloadSectorOptions",155],[5,"DownloadedSector",155],[6,"PlottingError",155],[10,"PieceGetter",155],[5,"EncodeSectorOptions",155],[10,"Table",655],[10,"Output",654],[10,"Sized",635],[1,"bool"],[5,"AcquireError",656],[5,"PieceIndex",657],[5,"Pin",658],[5,"PlotSectorOptions",155],[10,"Error",659],[10,"ProvableSolutions",328],[5,"SolutionCandidates",328],[6,"ProvingError",328],[6,"SectorContentsMapFromBytesError",447],[5,"Error",645],[6,"ReadingError",384],[5,"Kzg",660],[5,"ErasureCoding",661],[17,"Item"],[5,"Solution",650],[10,"Copy",635],[5,"PosSeed",650],[10,"FnMut",662],[5,"PlotRecord",384],[5,"PieceOffset",657],[5,"SectorId",650],[5,"Piece",657],[1,"u16"],[1,"array"],[5,"SectorContentsMap",447],[5,"Scalar",663],[10,"ExactSizeIterator",664],[5,"SectorMetadata",447],[6,"SectorContentsMapEncodeIntoError",447],[6,"SectorContentsMapIterationError",447],[5,"EncodedChunksUsed",447],[17,"Target"],[10,"Deref",665],[10,"DerefMut",665],[5,"BitArray",666],[5,"SBucket",657],[1,"tuple"],[10,"Iterator",667],[10,"IndexedParallelIterator",668],[10,"FnOnce",662],[15,"SBucketReading",143],[15,"FailedToRetrievePiece",319],[15,"FailedToAcquirePermit",319],[15,"BadSectorOutputSize",319],[15,"BadSectorMetadataOutputSize",319],[15,"PieceNotFound",319],[15,"PieceRecoveryFailed",319],[15,"FailedToCreateChunkWitness",379],[15,"FailedToCreatePolynomialForRecord",379],[15,"WrongRecordSizeAfterDecoding",437],[15,"FailedToReadChunk",437],[15,"InvalidChunk",437],[15,"FailedToErasureDecodeRecord",437],[15,"InvalidBytesLength",626],[15,"InvalidBytesLength",628],[15,"InvalidEncodedRecordChunks",628],[15,"SBucketOutOfRange",632]],"b":[[44,"impl-From%3CVec%3Cu8%3E%3E-for-AsyncReadBytes%3CVec%3Cu8%3E%3E"],[45,"impl-From%3CBox%3C%5Bu8%5D%3E%3E-for-AsyncReadBytes%3CBox%3C%5Bu8%5D%3E%3E"],[69,"impl-ReadAtAsync-for-ReadAtOffset%3C\'_,+T%3E"],[70,"impl-ReadAtSync-for-%26ReadAtOffset%3C\'_,+T%3E"],[71,"impl-ReadAtAsync-for-%26ReadAtOffset%3C\'_,+T%3E"],[72,"impl-ReadAtSync-for-ReadAtOffset%3C\'_,+T%3E"],[120,"impl-Display-for-AuditingError"],[121,"impl-Debug-for-AuditingError"],[228,"impl-Debug-for-PlottingError"],[229,"impl-Display-for-PlottingError"],[350,"impl-Display-for-ProvingError"],[351,"impl-Debug-for-ProvingError"],[353,"impl-From%3CSectorContentsMapFromBytesError%3E-for-ProvingError"],[354,"impl-From%3CError%3E-for-ProvingError"],[355,"impl-From%3CReadingError%3E-for-ProvingError"],[406,"impl-Display-for-ReadingError"],[407,"impl-Debug-for-ReadingError"],[409,"impl-From%3CError%3E-for-ReadingError"],[411,"impl-From%3CSectorContentsMapFromBytesError%3E-for-ReadingError"],[528,"impl-Display-for-SectorContentsMapFromBytesError"],[529,"impl-Debug-for-SectorContentsMapFromBytesError"],[530,"impl-Debug-for-SectorContentsMapEncodeIntoError"],[531,"impl-Display-for-SectorContentsMapEncodeIntoError"],[532,"impl-Debug-for-SectorContentsMapIterationError"],[533,"impl-Display-for-SectorContentsMapIterationError"]]}],\
diff --git a/settings.html b/settings.html
index fa19562571..51589d0c3f 100644
--- a/settings.html
+++ b/settings.html
@@ -1,2 +1,2 @@
-Settings

-    
Rustdoc settings
Back

\ No newline at end of file
+Settings

+    
Rustdoc settings
Back

\ No newline at end of file
diff --git a/src/sc_consensus_subspace/archiver.rs.html b/src/sc_consensus_subspace/archiver.rs.html
index 2b8498a64c..d79dad7e4b 100644
--- a/src/sc_consensus_subspace/archiver.rs.html
+++ b/src/sc_consensus_subspace/archiver.rs.html
@@ -919,6 +919,12 @@ 
Files

 917
 918
 919
+920
+921
+922
+923
+924
+925
 
// Copyright (C) 2021 Subspace Labs, Inc.
 // SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
 
@@ -990,7 +996,6 @@ 
Files

 use sp_runtime::{Justifications, Saturating};
 use std::error::Error;
 use std::future::Future;
-use std::num::NonZeroUsize;
 use std::slice;
 use std::sync::atomic::{AtomicU16, Ordering};
 use std::sync::Arc;
@@ -1011,8 +1016,7 @@ 
Files

 /// Ideally, we'd decouple pruning from finalization, but it may require invasive changes in
 /// Substrate and is not worth it right now.
 /// https://github.com/paritytech/substrate/discussions/14359
-pub(crate) const FINALIZATION_DEPTH_IN_SEGMENTS: NonZeroUsize =
-    NonZeroUsize::new(5).expect("Not zero; qed");
+pub(crate) const FINALIZATION_DEPTH_IN_SEGMENTS: SegmentIndex = SegmentIndex::new(5);
 
 #[derive(Debug)]
 struct SegmentHeadersStoreInner<AS> {
@@ -1784,27 +1788,35 @@ 
Files

             }
 
             if !new_segment_headers.is_empty() {
-                let maybe_block_number_to_finalize = {
-                    let mut segment_headers = segment_headers.lock();
-                    segment_headers.put(block_number + One::one(), new_segment_headers);
+                segment_headers
+                    .lock()
+                    .put(block_number + One::one(), new_segment_headers);
 
+                let maybe_block_number_to_finalize = segment_headers_store
+                    .max_segment_index()
                     // Skip last `FINALIZATION_DEPTH_IN_SEGMENTS` archived segments
-                    segment_headers
-                        .iter()
-                        .flat_map(|(_k, v)| v.iter().rev())
-                        .nth(FINALIZATION_DEPTH_IN_SEGMENTS.get())
-                        .map(|segment_header| segment_header.last_archived_block().number)
-                };
+                    .and_then(|max_segment_index| {
+                        max_segment_index.checked_sub(FINALIZATION_DEPTH_IN_SEGMENTS)
+                    })
+                    .and_then(|segment_index| {
+                        segment_headers_store.get_segment_header(segment_index)
+                    })
+                    .map(|segment_header| segment_header.last_archived_block().number)
+                    // Make sure not to finalize block number that does not yet exist (segment
+                    // headers store may contain future blocks during initial sync)
+                    .map(|block_number| best_archived_block_number.min(block_number.into()))
+                    // Do not finalize blocks twice
+                    .filter(|block_number| *block_number > client.info().finalized_number);
 
                 if let Some(block_number_to_finalize) = maybe_block_number_to_finalize {
                     let block_hash_to_finalize = client
-                        .hash(block_number_to_finalize.into())?
+                        .hash(block_number_to_finalize)?
                         .expect("Block about to be finalized must always exist");
                     finalize_block(
                         client.as_ref(),
                         telemetry.clone(),
                         block_hash_to_finalize,
-                        block_number_to_finalize.into(),
+                        block_number_to_finalize,
                     );
                 }
             }
diff --git a/src/sc_consensus_subspace/lib.rs.html b/src/sc_consensus_subspace/lib.rs.html
index 4a8354256e..2256b0fe0e 100644
--- a/src/sc_consensus_subspace/lib.rs.html
+++ b/src/sc_consensus_subspace/lib.rs.html
@@ -148,6 +148,8 @@ 
Files

 146
 147
 148
+149
+150
 
// Copyright (C) 2021 Subspace Labs, Inc.
 // SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
 
@@ -193,6 +195,7 @@ 
Files

 use parking_lot::Mutex;
 use sp_consensus_subspace::ChainConstants;
 use sp_runtime::traits::{Block as BlockT, NumberFor};
+use std::num::NonZeroUsize;
 use std::sync::Arc;
 use subspace_core_primitives::crypto::kzg::Kzg;
 use subspace_core_primitives::SegmentHeader;
@@ -239,7 +242,8 @@ 
Files

             block_importing_notification_sender,
             block_importing_notification_stream,
             segment_headers: Arc::new(Mutex::new(LruCache::new(
-                FINALIZATION_DEPTH_IN_SEGMENTS.saturating_add(1),
+                NonZeroUsize::new(u64::from(FINALIZATION_DEPTH_IN_SEGMENTS) as usize + 1)
+                    .expect("Not zero; qed"),
             ))),
             chain_constants,
             kzg,
diff --git a/src/subspace_core_primitives/segments.rs.html b/src/subspace_core_primitives/segments.rs.html
index d8994b98d7..c88c8dd96c 100644
--- a/src/subspace_core_primitives/segments.rs.html
+++ b/src/subspace_core_primitives/segments.rs.html
@@ -338,6 +338,18 @@ 
Files
336 337 338 +339 +340 +341 +342 +343 +344 +345 +346 +347 +348 +349 +350 
use crate::crypto::kzg::Commitment;
 use crate::pieces::{FlatPieces, Piece, PieceIndex, RawRecord};
 use alloc::boxed::Box;
@@ -409,6 +421,12 @@ 
Files
/// Segment index 1. pub const ONE: SegmentIndex = SegmentIndex(1); + /// Create new instance + #[inline] + pub const fn new(n: u64) -> Self { + Self(n) + } + /// Get the first piece index in this segment. pub fn first_piece_index(&self) -> PieceIndex { PieceIndex::from(self.0 * ArchivedHistorySegment::NUM_PIECES as u64) @@ -449,6 +467,12 @@

Files

source_first_piece_indices } + + /// Checked integer subtraction. Computes `self - rhs`, returning `None` if overflow occurred. + #[inline] + pub fn checked_sub(self, rhs: Self) -> Option<Self> { + self.0.checked_sub(rhs.0).map(Self) + } } /// Segment commitment contained within segment header. diff --git a/subspace_core_primitives/crypto/kzg/struct.Commitment.html b/subspace_core_primitives/crypto/kzg/struct.Commitment.html index 6567c7b589..1d73178e4d 100644 --- a/subspace_core_primitives/crypto/kzg/struct.Commitment.html +++ b/subspace_core_primitives/crypto/kzg/struct.Commitment.html @@ -30,9 +30,9 @@ efficiency purposes.

source

pub fn vec_option_from_repr(value: Vec<Option<FsG1>>) -> Vec<Option<Self>>

Convenient conversion from vector of optional underlying representation to commitment for efficiency purposes.

-

Trait Implementations§

source§

impl AsMut<FsG1> for Commitment

source§

fn as_mut(&mut self) -> &mut FsG1

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl AsRef<FsG1> for Commitment

source§

fn as_ref(&self) -> &FsG1

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl Clone for Commitment

source§

fn clone(&self) -> Commitment

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Commitment

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for Commitment

source§

fn default() -> Commitment

Returns the “default value” for a type. Read more
source§

impl Deref for Commitment

§

type Target = FsG1

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for Commitment

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl From<&Commitment> for [u8; 48]

source§

fn from(commitment: &Commitment) -> Self

Converts to this type from the input type.
source§

impl From<Commitment> for [u8; 48]

source§

fn from(commitment: Commitment) -> Self

Converts to this type from the input type.
source§

impl From<Commitment> for FsG1

source§

fn from(original: Commitment) -> Self

Converts to this type from the input type.
source§

impl From<Commitment> for RecordCommitment

source§

fn from(commitment: Commitment) -> Self

Converts to this type from the input type.
source§

impl From<Commitment> for SegmentCommitment

source§

fn from(commitment: Commitment) -> Self

Converts to this type from the input type.
source§

impl From<FsG1> for Commitment

source§

fn from(original: FsG1) -> Commitment

Converts to this type from the input type.
source§

impl PartialEq for Commitment

source§

fn eq(&self, other: &Commitment) -> bool

This method tests for self and other values to be equal, and is used +

Trait Implementations§

source§

impl AsMut<FsG1> for Commitment

source§

fn as_mut(&mut self) -> &mut FsG1

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl AsRef<FsG1> for Commitment

source§

fn as_ref(&self) -> &FsG1

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl Clone for Commitment

source§

fn clone(&self) -> Commitment

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Commitment

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for Commitment

source§

fn default() -> Commitment

Returns the “default value” for a type. Read more
source§

impl Deref for Commitment

§

type Target = FsG1

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for Commitment

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl From<&Commitment> for [u8; 48]

source§

fn from(commitment: &Commitment) -> Self

Converts to this type from the input type.
source§

impl From<Commitment> for [u8; 48]

source§

fn from(commitment: Commitment) -> Self

Converts to this type from the input type.
source§

impl From<Commitment> for FsG1

source§

fn from(original: Commitment) -> Self

Converts to this type from the input type.
source§

impl From<Commitment> for RecordCommitment

source§

fn from(commitment: Commitment) -> Self

Converts to this type from the input type.
source§

impl From<Commitment> for SegmentCommitment

source§

fn from(commitment: Commitment) -> Self

Converts to this type from the input type.
source§

impl From<FsG1> for Commitment

source§

fn from(original: FsG1) -> Commitment

Converts to this type from the input type.
source§

impl PartialEq for Commitment

source§

fn eq(&self, other: &Commitment) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always -sufficient, and should not be overridden without very good reason.
source§

impl TryFrom<&[u8; 48]> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl TryFrom<&RecordCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: &RecordCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<&SegmentCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: &SegmentCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<[u8; 48]> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(bytes: [u8; 48]) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<RecordCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: RecordCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<SegmentCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: SegmentCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl Copy for Commitment

source§

impl Eq for Commitment

source§

impl StructuralEq for Commitment

source§

impl StructuralPartialEq for Commitment

Auto Trait Implementations§

§

impl RefUnwindSafe for Commitment

§

impl Send for Commitment

§

impl Sync for Commitment

§

impl Unpin for Commitment

§

impl UnwindSafe for Commitment

Blanket Implementations§

source§

impl<T> Any for T
where +sufficient, and should not be overridden without very good reason.

source§

impl TryFrom<&[u8; 48]> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

impl TryFrom<&RecordCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: &RecordCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<&SegmentCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: &SegmentCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<[u8; 48]> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(bytes: [u8; 48]) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<RecordCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: RecordCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<SegmentCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: SegmentCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl Copy for Commitment

source§

impl Eq for Commitment

source§

impl StructuralEq for Commitment

source§

impl StructuralPartialEq for Commitment

Auto Trait Implementations§

§

impl RefUnwindSafe for Commitment

§

impl Send for Commitment

§

impl Sync for Commitment

§

impl Unpin for Commitment

§

impl UnwindSafe for Commitment

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

diff --git a/subspace_core_primitives/struct.ArchivedHistorySegment.html b/subspace_core_primitives/struct.ArchivedHistorySegment.html index e4c4df08b4..8f4d1a8b8a 100644 --- a/subspace_core_primitives/struct.ArchivedHistorySegment.html +++ b/subspace_core_primitives/struct.ArchivedHistorySegment.html @@ -1,7 +1,7 @@ ArchivedHistorySegment in subspace_core_primitives - Rust
-

Struct subspace_core_primitives::ArchivedHistorySegment

source · 
pub struct ArchivedHistorySegment(/* private fields */);
Expand description

Archived history segment after archiving is applied.

-

Implementations§

source§

impl ArchivedHistorySegment

source

pub const NUM_PIECES: usize = 256usize

Number of pieces in one segment of archived history.

-
source

pub const SIZE: usize = 268_460_032usize

Size of archived history segment in bytes.

+

Struct subspace_core_primitives::ArchivedHistorySegment

source · 
pub struct ArchivedHistorySegment(/* private fields */);
Expand description

Archived history segment after archiving is applied.

+

Implementations§

source§

impl ArchivedHistorySegment

source

pub const NUM_PIECES: usize = 256usize

Number of pieces in one segment of archived history.

+
source

pub const SIZE: usize = 268_460_032usize

Size of archived history segment in bytes.

It includes erasure coded crate::pieces::PieceArrays (both source and parity) that are composed from crate::pieces::Records together with corresponding commitments and witnesses.

Methods from Deref<Target = FlatPieces>§

source

pub fn source(&self) -> impl ExactSizeIterator<Item = &PieceArray> + '_

Iterator over source pieces (even indices).

@@ -3055,23 +3055,23 @@
Examples
Examples
assert_eq!(["hello", "world"].connect(" "), "hello world");
 assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);
-

Trait Implementations§

source§

impl Clone for ArchivedHistorySegment

source§

fn clone(&self) -> ArchivedHistorySegment

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for ArchivedHistorySegment

source§

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

Formats the value using the given formatter. Read more
source§

impl Decode for ArchivedHistorySegment

source§

fn decode<__CodecInputEdqy: Input>( +

Trait Implementations§

source§

impl Clone for ArchivedHistorySegment

source§

fn clone(&self) -> ArchivedHistorySegment

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for ArchivedHistorySegment

source§

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

Formats the value using the given formatter. Read more
source§

impl Decode for ArchivedHistorySegment

source§

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy -) -> Result<Self, Error>

Attempt to deserialise the value from input.
source§

fn decode_into<__CodecInputEdqy: Input>( +) -> Result<Self, Error>

Attempt to deserialise the value from input.
source§

fn decode_into<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, dst_: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>

Attempt to deserialize the value from input into a pre-allocated piece of memory. Read more
§

fn skip<I>(input: &mut I) -> Result<(), Error>
where - I: Input,

Attempt to skip the encoded value from input. Read more
§

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
source§

impl Default for ArchivedHistorySegment

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl Deref for ArchivedHistorySegment

§

type Target = FlatPieces

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for ArchivedHistorySegment

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl<'de> Deserialize<'de> for ArchivedHistorySegment

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where - __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Encode for ArchivedHistorySegment

source§

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
source§

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( + I: Input,

Attempt to skip the encoded value from input. Read more
§

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
source§

impl Default for ArchivedHistorySegment

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl Deref for ArchivedHistorySegment

§

type Target = FlatPieces

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for ArchivedHistorySegment

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl<'de> Deserialize<'de> for ArchivedHistorySegment

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Encode for ArchivedHistorySegment

source§

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
source§

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy -)

Convert self to a slice and append it to the destination.
source§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
source§

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( +)

Convert self to a slice and append it to the destination.
source§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
source§

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( &self, f: __CodecUsingEncodedCallback -) -> __CodecOutputReturn

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
source§

impl MaxEncodedLen for ArchivedHistorySegment

source§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
source§

impl PartialEq for ArchivedHistorySegment

source§

fn eq(&self, other: &ArchivedHistorySegment) -> bool

This method tests for self and other values to be equal, and is used +) -> __CodecOutputReturn
Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
source§

impl MaxEncodedLen for ArchivedHistorySegment

source§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
source§

impl PartialEq for ArchivedHistorySegment

source§

fn eq(&self, other: &ArchivedHistorySegment) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always -sufficient, and should not be overridden without very good reason.
source§

impl Serialize for ArchivedHistorySegment

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where - __S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl TypeInfo for ArchivedHistorySegment

§

type Identity = ArchivedHistorySegment

The type identifying for which type info is provided. Read more
source§

fn type_info() -> Type

Returns the static type identifier for Self.
source§

impl EncodeLike for ArchivedHistorySegment

source§

impl Eq for ArchivedHistorySegment

source§

impl StructuralEq for ArchivedHistorySegment

source§

impl StructuralPartialEq for ArchivedHistorySegment

Auto Trait Implementations§

§

impl RefUnwindSafe for ArchivedHistorySegment

§

impl Send for ArchivedHistorySegment

§

impl Sync for ArchivedHistorySegment

§

impl Unpin for ArchivedHistorySegment

§

impl UnwindSafe for ArchivedHistorySegment

Blanket Implementations§

source§

impl<T> Any for T
where +sufficient, and should not be overridden without very good reason.

source§

impl Serialize for ArchivedHistorySegment

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl TypeInfo for ArchivedHistorySegment

§

type Identity = ArchivedHistorySegment

The type identifying for which type info is provided. Read more
source§

fn type_info() -> Type

Returns the static type identifier for Self.
source§

impl EncodeLike for ArchivedHistorySegment

source§

impl Eq for ArchivedHistorySegment

source§

impl StructuralEq for ArchivedHistorySegment

source§

impl StructuralPartialEq for ArchivedHistorySegment

Auto Trait Implementations§

§

impl RefUnwindSafe for ArchivedHistorySegment

§

impl Send for ArchivedHistorySegment

§

impl Sync for ArchivedHistorySegment

§

impl Unpin for ArchivedHistorySegment

§

impl UnwindSafe for ArchivedHistorySegment

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> DecodeAll for T
where diff --git a/subspace_core_primitives/struct.HistorySize.html b/subspace_core_primitives/struct.HistorySize.html index 7c37009e08..033f6c8415 100644 --- a/subspace_core_primitives/struct.HistorySize.html +++ b/subspace_core_primitives/struct.HistorySize.html @@ -1,34 +1,34 @@ HistorySize in subspace_core_primitives - Rust
-

Struct subspace_core_primitives::HistorySize

source · 
pub struct HistorySize(/* private fields */);
Expand description

Size of blockchain history in segments.

-

Implementations§

source§

impl HistorySize

source

pub const fn new(value: NonZeroU64) -> Self

Create new instance.

-
source

pub const fn in_pieces(&self) -> NonZeroU64

Size of blockchain history in pieces.

-
source

pub fn segment_index(&self) -> SegmentIndex

Segment index that corresponds to this history size.

-
source

pub fn sector_expiration_check(&self, min_sector_lifetime: Self) -> Option<Self>

History size at which expiration check for sector happens.

+

Struct subspace_core_primitives::HistorySize

source · 
pub struct HistorySize(/* private fields */);
Expand description

Size of blockchain history in segments.

+

Implementations§

source§

impl HistorySize

source

pub const fn new(value: NonZeroU64) -> Self

Create new instance.

+
source

pub const fn in_pieces(&self) -> NonZeroU64

Size of blockchain history in pieces.

+
source

pub fn segment_index(&self) -> SegmentIndex

Segment index that corresponds to this history size.

+
source

pub fn sector_expiration_check(&self, min_sector_lifetime: Self) -> Option<Self>

History size at which expiration check for sector happens.

Returns None on overflow.

-

Methods from Deref<Target = NonZeroU64>§

1.70.0 · source

pub const MIN: NonZeroU64 = _

1.70.0 · source

pub const MAX: NonZeroU64 = _

1.67.0 · source

pub const BITS: u32 = 64u32

Trait Implementations§

source§

impl Clone for HistorySize

source§

fn clone(&self) -> HistorySize

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for HistorySize

source§

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

Formats the value using the given formatter. Read more
source§

impl Decode for HistorySize

source§

fn decode<__CodecInputEdqy: Input>( +

Methods from Deref<Target = NonZeroU64>§

1.70.0 · source

pub const MIN: NonZeroU64 = _

1.70.0 · source

pub const MAX: NonZeroU64 = _

1.67.0 · source

pub const BITS: u32 = 64u32

Trait Implementations§

source§

impl Clone for HistorySize

source§

fn clone(&self) -> HistorySize

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for HistorySize

source§

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

Formats the value using the given formatter. Read more
source§

impl Decode for HistorySize

source§

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy -) -> Result<Self, Error>

Attempt to deserialise the value from input.
source§

fn decode_into<__CodecInputEdqy: Input>( +) -> Result<Self, Error>

Attempt to deserialise the value from input.
source§

fn decode_into<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, dst_: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>

Attempt to deserialize the value from input into a pre-allocated piece of memory. Read more
§

fn skip<I>(input: &mut I) -> Result<(), Error>
where - I: Input,

Attempt to skip the encoded value from input. Read more
§

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
source§

impl Deref for HistorySize

§

type Target = NonZeroU64

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for HistorySize

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl<'de> Deserialize<'de> for HistorySize

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where - __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Display for HistorySize

source§

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

Formats the value using the given formatter. Read more
source§

impl Encode for HistorySize

source§

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
source§

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( + I: Input,

Attempt to skip the encoded value from input. Read more
§

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
source§

impl Deref for HistorySize

§

type Target = NonZeroU64

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for HistorySize

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl<'de> Deserialize<'de> for HistorySize

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Display for HistorySize

source§

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

Formats the value using the given formatter. Read more
source§

impl Encode for HistorySize

source§

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
source§

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy -)

Convert self to a slice and append it to the destination.
source§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
source§

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( +)

Convert self to a slice and append it to the destination.
source§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
source§

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( &self, f: __CodecUsingEncodedCallback -) -> __CodecOutputReturn

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
source§

impl From<HistorySize> for NonZeroU64

source§

fn from(original: HistorySize) -> Self

Converts to this type from the input type.
source§

impl From<NonZeroU64> for HistorySize

source§

fn from(original: NonZeroU64) -> HistorySize

Converts to this type from the input type.
source§

impl From<SegmentIndex> for HistorySize

source§

fn from(value: SegmentIndex) -> Self

Converts to this type from the input type.
source§

impl Hash for HistorySize

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where +) -> __CodecOutputReturn

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
source§

impl From<HistorySize> for NonZeroU64

source§

fn from(original: HistorySize) -> Self

Converts to this type from the input type.
source§

impl From<NonZeroU64> for HistorySize

source§

fn from(original: NonZeroU64) -> HistorySize

Converts to this type from the input type.
source§

impl From<SegmentIndex> for HistorySize

source§

fn from(value: SegmentIndex) -> Self

Converts to this type from the input type.
source§

impl Hash for HistorySize

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, - Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl MaxEncodedLen for HistorySize

source§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
source§

impl Ord for HistorySize

source§

fn cmp(&self, other: &HistorySize) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where + Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl MaxEncodedLen for HistorySize

source§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
source§

impl Ord for HistorySize

source§

fn cmp(&self, other: &HistorySize) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where - Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
source§

impl PartialEq for HistorySize

source§

fn eq(&self, other: &HistorySize) -> bool

This method tests for self and other values to be equal, and is used + Self: Sized + PartialOrd,
Restrict a value to a certain interval. Read more
source§

impl PartialEq for HistorySize

source§

fn eq(&self, other: &HistorySize) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always -sufficient, and should not be overridden without very good reason.
source§

impl PartialOrd for HistorySize

source§

fn partial_cmp(&self, other: &HistorySize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= +sufficient, and should not be overridden without very good reason.
source§

impl PartialOrd for HistorySize

source§

fn partial_cmp(&self, other: &HistorySize) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator. Read more
1.0.0 · source§

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= -operator. Read more
source§

impl Serialize for HistorySize

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where - __S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl TypeInfo for HistorySize

§

type Identity = HistorySize

The type identifying for which type info is provided. Read more
source§

fn type_info() -> Type

Returns the static type identifier for Self.
source§

impl Copy for HistorySize

source§

impl EncodeLike for HistorySize

source§

impl Eq for HistorySize

source§

impl StructuralEq for HistorySize

source§

impl StructuralPartialEq for HistorySize

Auto Trait Implementations§

§

impl RefUnwindSafe for HistorySize

§

impl Send for HistorySize

§

impl Sync for HistorySize

§

impl Unpin for HistorySize

§

impl UnwindSafe for HistorySize

Blanket Implementations§

source§

impl<T> Any for T
where +operator. Read more

source§

impl Serialize for HistorySize

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl TypeInfo for HistorySize

§

type Identity = HistorySize

The type identifying for which type info is provided. Read more
source§

fn type_info() -> Type

Returns the static type identifier for Self.
source§

impl Copy for HistorySize

source§

impl EncodeLike for HistorySize

source§

impl Eq for HistorySize

source§

impl StructuralEq for HistorySize

source§

impl StructuralPartialEq for HistorySize

Auto Trait Implementations§

§

impl RefUnwindSafe for HistorySize

§

impl Send for HistorySize

§

impl Sync for HistorySize

§

impl Unpin for HistorySize

§

impl UnwindSafe for HistorySize

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> DecodeAll for T
where diff --git a/subspace_core_primitives/struct.RecordedHistorySegment.html b/subspace_core_primitives/struct.RecordedHistorySegment.html index 31e941c702..e290ae3683 100644 --- a/subspace_core_primitives/struct.RecordedHistorySegment.html +++ b/subspace_core_primitives/struct.RecordedHistorySegment.html @@ -1,13 +1,13 @@ RecordedHistorySegment in subspace_core_primitives - Rust
-

Struct subspace_core_primitives::RecordedHistorySegment

source · 
pub struct RecordedHistorySegment(/* private fields */);
Expand description

Recorded history segment before archiving is applied.

+

Struct subspace_core_primitives::RecordedHistorySegment

source · 
pub struct RecordedHistorySegment(/* private fields */);
Expand description

Recorded history segment before archiving is applied.

NOTE: This is a stack-allocated data structure and can cause stack overflow!

-

Implementations§

source§

impl RecordedHistorySegment

source

pub const NUM_RAW_RECORDS: usize = 128usize

Number of raw records in one segment of recorded history.

-
source

pub const ERASURE_CODING_RATE: (usize, usize) = _

Erasure coding rate for records during archiving process.

-
source

pub const SIZE: usize = 130_023_424usize

Size of recorded history segment in bytes.

+

Implementations§

source§

impl RecordedHistorySegment

source

pub const NUM_RAW_RECORDS: usize = 128usize

Number of raw records in one segment of recorded history.

+
source

pub const ERASURE_CODING_RATE: (usize, usize) = _

Erasure coding rate for records during archiving process.

+
source

pub const SIZE: usize = 130_023_424usize

Size of recorded history segment in bytes.

It includes half of the records (just source records) that will later be erasure coded and together with corresponding commitments and witnesses will result in ArchivedHistorySegment::NUM_PIECES Pieces of archival history.

-
source

pub fn new_boxed() -> Box<Self>

Create boxed value without hitting stack overflow

+
source

pub fn new_boxed() -> Box<Self>

Create boxed value without hitting stack overflow

Methods from Deref<Target = [RawRecord; 128]>§

1.57.0 · source

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

1.57.0 · source

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

@@ -144,9 +144,9 @@
Examples
without checking whether they’re valid.

Safety

Every byte in the array must be in 0..=127, or else this is UB.

-

Trait Implementations§

source§

impl AsMut<[u8]> for RecordedHistorySegment

source§

fn as_mut(&mut self) -> &mut [u8] ⓘ

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl AsRef<[u8]> for RecordedHistorySegment

source§

fn as_ref(&self) -> &[u8] ⓘ

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl Clone for RecordedHistorySegment

source§

fn clone(&self) -> RecordedHistorySegment

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for RecordedHistorySegment

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for RecordedHistorySegment

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl Deref for RecordedHistorySegment

§

type Target = [RawRecord; 128]

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for RecordedHistorySegment

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl PartialEq for RecordedHistorySegment

source§

fn eq(&self, other: &RecordedHistorySegment) -> bool

This method tests for self and other values to be equal, and is used +

Trait Implementations§

source§

impl AsMut<[u8]> for RecordedHistorySegment

source§

fn as_mut(&mut self) -> &mut [u8] ⓘ

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl AsRef<[u8]> for RecordedHistorySegment

source§

fn as_ref(&self) -> &[u8] ⓘ

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl Clone for RecordedHistorySegment

source§

fn clone(&self) -> RecordedHistorySegment

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for RecordedHistorySegment

source§

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

Formats the value using the given formatter. Read more
source§

impl Default for RecordedHistorySegment

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl Deref for RecordedHistorySegment

§

type Target = [RawRecord; 128]

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for RecordedHistorySegment

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl PartialEq for RecordedHistorySegment

source§

fn eq(&self, other: &RecordedHistorySegment) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always -sufficient, and should not be overridden without very good reason.
source§

impl Copy for RecordedHistorySegment

source§

impl Eq for RecordedHistorySegment

source§

impl StructuralEq for RecordedHistorySegment

source§

impl StructuralPartialEq for RecordedHistorySegment

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where +sufficient, and should not be overridden without very good reason.

source§

impl Copy for RecordedHistorySegment

source§

impl Eq for RecordedHistorySegment

source§

impl StructuralEq for RecordedHistorySegment

source§

impl StructuralPartialEq for RecordedHistorySegment

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T, U> AsByteSlice<T> for U
where T: ToByteSlice, U: AsRef<[T]> + ?Sized,

§

fn as_byte_slice(&self) -> &[u8] ⓘ

§

impl<T, U> AsMutByteSlice<T> for U
where diff --git a/subspace_core_primitives/struct.SegmentCommitment.html b/subspace_core_primitives/struct.SegmentCommitment.html index ff4fe5822f..d14066502d 100644 --- a/subspace_core_primitives/struct.SegmentCommitment.html +++ b/subspace_core_primitives/struct.SegmentCommitment.html @@ -1,6 +1,6 @@ SegmentCommitment in subspace_core_primitives - Rust
-

Struct subspace_core_primitives::SegmentCommitment

source · 
pub struct SegmentCommitment(/* private fields */);
Expand description

Segment commitment contained within segment header.

-

Implementations§

source§

impl SegmentCommitment

source

pub const SIZE: usize = 48usize

Size of segment commitment in bytes.

+

Struct subspace_core_primitives::SegmentCommitment

source · 
pub struct SegmentCommitment(/* private fields */);
Expand description

Segment commitment contained within segment header.

+

Implementations§

source§

impl SegmentCommitment

source

pub const SIZE: usize = 48usize

Size of segment commitment in bytes.

Methods from Deref<Target = [u8; 48]>§

1.57.0 · source

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

1.57.0 · source

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

@@ -137,25 +137,25 @@
Examples
without checking whether they’re valid.

Safety

Every byte in the array must be in 0..=127, or else this is UB.

-

Trait Implementations§

source§

impl AsMut<[u8]> for SegmentCommitment

source§

fn as_mut(&mut self) -> &mut [u8] ⓘ

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl AsRef<[u8]> for SegmentCommitment

source§

fn as_ref(&self) -> &[u8] ⓘ

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl Clone for SegmentCommitment

source§

fn clone(&self) -> SegmentCommitment

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for SegmentCommitment

source§

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

Formats the value using the given formatter. Read more
source§

impl Decode for SegmentCommitment

source§

fn decode<__CodecInputEdqy: Input>( +

Trait Implementations§

source§

impl AsMut<[u8]> for SegmentCommitment

source§

fn as_mut(&mut self) -> &mut [u8] ⓘ

Converts this type into a mutable reference of the (usually inferred) input type.
source§

impl AsRef<[u8]> for SegmentCommitment

source§

fn as_ref(&self) -> &[u8] ⓘ

Converts this type into a shared reference of the (usually inferred) input type.
source§

impl Clone for SegmentCommitment

source§

fn clone(&self) -> SegmentCommitment

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for SegmentCommitment

source§

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

Formats the value using the given formatter. Read more
source§

impl Decode for SegmentCommitment

source§

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy -) -> Result<Self, Error>

Attempt to deserialise the value from input.
source§

fn decode_into<__CodecInputEdqy: Input>( +) -> Result<Self, Error>

Attempt to deserialise the value from input.
source§

fn decode_into<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy, dst_: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>

Attempt to deserialize the value from input into a pre-allocated piece of memory. Read more
§

fn skip<I>(input: &mut I) -> Result<(), Error>
where - I: Input,

Attempt to skip the encoded value from input. Read more
§

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
source§

impl Default for SegmentCommitment

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl Deref for SegmentCommitment

§

type Target = [u8; 48]

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for SegmentCommitment

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl<'de> Deserialize<'de> for SegmentCommitment

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where - __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Encode for SegmentCommitment

source§

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
source§

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( + I: Input,

Attempt to skip the encoded value from input. Read more
§

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
source§

impl Default for SegmentCommitment

source§

fn default() -> Self

Returns the “default value” for a type. Read more
source§

impl Deref for SegmentCommitment

§

type Target = [u8; 48]

The resulting type after dereferencing.
source§

fn deref(&self) -> &Self::Target

Dereferences the value.
source§

impl DerefMut for SegmentCommitment

source§

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.
source§

impl<'de> Deserialize<'de> for SegmentCommitment

source§

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where + __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
source§

impl Encode for SegmentCommitment

source§

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
source§

fn encode_to<__CodecOutputEdqy: Output + ?Sized>( &self, __codec_dest_edqy: &mut __CodecOutputEdqy -)

Convert self to a slice and append it to the destination.
source§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
source§

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( +)

Convert self to a slice and append it to the destination.
source§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
source§

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( &self, f: __CodecUsingEncodedCallback -) -> __CodecOutputReturn

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
source§

impl From<[u8; 48]> for SegmentCommitment

source§

fn from(original: [u8; 48]) -> SegmentCommitment

Converts to this type from the input type.
source§

impl From<Commitment> for SegmentCommitment

source§

fn from(commitment: Commitment) -> Self

Converts to this type from the input type.
source§

impl From<SegmentCommitment> for [u8; 48]

source§

fn from(original: SegmentCommitment) -> Self

Converts to this type from the input type.
source§

impl Hash for SegmentCommitment

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where +) -> __CodecOutputReturn

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
source§

impl From<[u8; 48]> for SegmentCommitment

source§

fn from(original: [u8; 48]) -> SegmentCommitment

Converts to this type from the input type.
source§

impl From<Commitment> for SegmentCommitment

source§

fn from(commitment: Commitment) -> Self

Converts to this type from the input type.
source§

impl From<SegmentCommitment> for [u8; 48]

source§

fn from(original: SegmentCommitment) -> Self

Converts to this type from the input type.
source§

impl Hash for SegmentCommitment

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, - Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl MaxEncodedLen for SegmentCommitment

source§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
source§

impl PartialEq for SegmentCommitment

source§

fn eq(&self, other: &SegmentCommitment) -> bool

This method tests for self and other values to be equal, and is used + Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl MaxEncodedLen for SegmentCommitment

source§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
source§

impl PartialEq for SegmentCommitment

source§

fn eq(&self, other: &SegmentCommitment) -> bool

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always -sufficient, and should not be overridden without very good reason.
source§

impl Serialize for SegmentCommitment

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where - __S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl TryFrom<&[u8]> for SegmentCommitment

§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<&SegmentCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: &SegmentCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<SegmentCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: SegmentCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TypeInfo for SegmentCommitment

§

type Identity = SegmentCommitment

The type identifying for which type info is provided. Read more
source§

fn type_info() -> Type

Returns the static type identifier for Self.
source§

impl Copy for SegmentCommitment

source§

impl EncodeLike for SegmentCommitment

source§

impl Eq for SegmentCommitment

source§

impl StructuralEq for SegmentCommitment

source§

impl StructuralPartialEq for SegmentCommitment

Auto Trait Implementations§

§

impl RefUnwindSafe for SegmentCommitment

§

impl Send for SegmentCommitment

§

impl Sync for SegmentCommitment

§

impl Unpin for SegmentCommitment

§

impl UnwindSafe for SegmentCommitment

Blanket Implementations§

source§

impl<T> Any for T
where +sufficient, and should not be overridden without very good reason.

source§

impl Serialize for SegmentCommitment

source§

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where + __S: Serializer,

Serialize this value into the given Serde serializer. Read more
source§

impl TryFrom<&[u8]> for SegmentCommitment

§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &[u8]) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<&SegmentCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: &SegmentCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TryFrom<SegmentCommitment> for Commitment

§

type Error = String

The type returned in the event of a conversion error.
source§

fn try_from(commitment: SegmentCommitment) -> Result<Self, Self::Error>

Performs the conversion.
source§

impl TypeInfo for SegmentCommitment

§

type Identity = SegmentCommitment

The type identifying for which type info is provided. Read more
source§

fn type_info() -> Type

Returns the static type identifier for Self.
source§

impl Copy for SegmentCommitment

source§

impl EncodeLike for SegmentCommitment

source§

impl Eq for SegmentCommitment

source§

impl StructuralEq for SegmentCommitment

source§

impl StructuralPartialEq for SegmentCommitment

Auto Trait Implementations§

§

impl RefUnwindSafe for SegmentCommitment

§

impl Send for SegmentCommitment

§

impl Sync for SegmentCommitment

§

impl Unpin for SegmentCommitment

§

impl UnwindSafe for SegmentCommitment

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T, U> AsByteSlice<T> for U
where T: ToByteSlice, U: AsRef<[T]> + ?Sized,

§

fn as_byte_slice(&self) -> &[u8] ⓘ

§

impl<T, U> AsMutByteSlice<T> for U
where diff --git a/subspace_core_primitives/struct.SegmentIndex.html b/subspace_core_primitives/struct.SegmentIndex.html index 77526638f1..38b62d3766 100644 --- a/subspace_core_primitives/struct.SegmentIndex.html +++ b/subspace_core_primitives/struct.SegmentIndex.html @@ -1,11 +1,13 @@ -SegmentIndex in subspace_core_primitives - Rust
+SegmentIndex in subspace_core_primitives - Rust

Struct subspace_core_primitives::SegmentIndex

source · 
pub struct SegmentIndex(/* private fields */);
Expand description

Segment index type.

-

Implementations§

source§

impl SegmentIndex

source

pub const ZERO: SegmentIndex = _

Segment index 0.

+

Implementations§

source§

impl SegmentIndex

source

pub const ZERO: SegmentIndex = _

Segment index 0.

source

pub const ONE: SegmentIndex = _

Segment index 1.

-
source

pub fn first_piece_index(&self) -> PieceIndex

Get the first piece index in this segment.

-
source

pub fn last_piece_index(&self) -> PieceIndex

Get the last piece index in this segment.

-
source

pub fn segment_piece_indexes(&self) -> [PieceIndex; 256]

List of piece indexes that belong to this segment.

-
source

pub fn segment_piece_indexes_source_first(&self) -> [PieceIndex; 256]

List of piece indexes that belong to this segment with source pieces first.

+
source

pub const fn new(n: u64) -> Self

Create new instance

+
source

pub fn first_piece_index(&self) -> PieceIndex

Get the first piece index in this segment.

+
source

pub fn last_piece_index(&self) -> PieceIndex

Get the last piece index in this segment.

+
source

pub fn segment_piece_indexes(&self) -> [PieceIndex; 256]

List of piece indexes that belong to this segment.

+
source

pub fn segment_piece_indexes_source_first(&self) -> [PieceIndex; 256]

List of piece indexes that belong to this segment with source pieces first.

+
source

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Checked integer subtraction. Computes self - rhs, returning None if overflow occurred.

Trait Implementations§

source§

impl Add for SegmentIndex

§

type Output = SegmentIndex

The resulting type after applying the + operator.
source§

fn add(self, rhs: SegmentIndex) -> SegmentIndex

Performs the + operation. Read more
source§

impl AddAssign for SegmentIndex

source§

fn add_assign(&mut self, rhs: SegmentIndex)

Performs the += operation. Read more
source§

impl Clone for SegmentIndex

source§

fn clone(&self) -> SegmentIndex

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for SegmentIndex

source§

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

Formats the value using the given formatter. Read more
source§

impl Decode for SegmentIndex

source§

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy ) -> Result<Self, Error>

Attempt to deserialise the value from input.
source§

fn decode_into<__CodecInputEdqy: Input>( @@ -21,7 +23,7 @@ )

Convert self to a slice and append it to the destination.
source§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
source§

fn using_encoded<__CodecOutputReturn, __CodecUsingEncodedCallback: FnOnce(&[u8]) -> __CodecOutputReturn>( &self, f: __CodecUsingEncodedCallback -) -> __CodecOutputReturn

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
source§

impl From<SegmentIndex> for HistorySize

source§

fn from(value: SegmentIndex) -> Self

Converts to this type from the input type.
source§

impl From<SegmentIndex> for u64

source§

fn from(original: SegmentIndex) -> Self

Converts to this type from the input type.
source§

impl From<u64> for SegmentIndex

source§

fn from(original: u64) -> SegmentIndex

Converts to this type from the input type.
source§

impl Hash for SegmentIndex

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where +) -> __CodecOutputReturn

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
source§

impl From<SegmentIndex> for HistorySize

source§

fn from(value: SegmentIndex) -> Self

Converts to this type from the input type.
source§

impl From<SegmentIndex> for u64

source§

fn from(original: SegmentIndex) -> Self

Converts to this type from the input type.
source§

impl From<u64> for SegmentIndex

source§

fn from(original: u64) -> SegmentIndex

Converts to this type from the input type.
source§

impl Hash for SegmentIndex

source§

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
source§

impl MaxEncodedLen for SegmentIndex

source§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
source§

impl<__RhsT> Mul<__RhsT> for SegmentIndex
where u64: Mul<__RhsT, Output = u64>,

§

type Output = SegmentIndex

The resulting type after applying the * operator.
source§

fn mul(self, rhs: __RhsT) -> SegmentIndex

Performs the * operation. Read more
source§

impl<__RhsT> MulAssign<__RhsT> for SegmentIndex
where diff --git a/subspace_test_client/chain_spec/type.TestChainSpec.html b/subspace_test_client/chain_spec/type.TestChainSpec.html index 55ad4f60dc..9918acfea7 100644 --- a/subspace_test_client/chain_spec/type.TestChainSpec.html +++ b/subspace_test_client/chain_spec/type.TestChainSpec.html @@ -1,3 +1,3 @@ TestChainSpec in subspace_test_client::chain_spec - Rust
-

Type Alias subspace_test_client::chain_spec::TestChainSpec

source · 
pub type TestChainSpec = GenericChainSpec<RuntimeGenesisConfig>;
Expand description

The ChainSpec parameterized for subspace test runtime.

+

Type Alias subspace_test_client::chain_spec::TestChainSpec

source · 
pub type TestChainSpec = GenericChainSpec<RuntimeGenesisConfig>;
Expand description

The ChainSpec parameterized for subspace test runtime.

Aliased Type§

struct TestChainSpec { /* private fields */ }
\ No newline at end of file diff --git a/subspace_test_client/type.Client.html b/subspace_test_client/type.Client.html index 70a5b097d0..019b8c1435 100644 --- a/subspace_test_client/type.Client.html +++ b/subspace_test_client/type.Client.html @@ -1,3 +1,3 @@ Client in subspace_test_client - Rust
-

Type Alias subspace_test_client::Client

source · 
pub type Client = FullClient<RuntimeApi>;
Expand description

The client type being used by the test service.

+

Type Alias subspace_test_client::Client

source · 
pub type Client = FullClient<RuntimeApi>;
Expand description

The client type being used by the test service.

Aliased Type§

struct Client { /* private fields */ }
\ No newline at end of file diff --git a/subspace_test_service/struct.MockConsensusNode.html b/subspace_test_service/struct.MockConsensusNode.html index f9a273caf4..555eb4669f 100644 --- a/subspace_test_service/struct.MockConsensusNode.html +++ b/subspace_test_service/struct.MockConsensusNode.html @@ -1,10 +1,10 @@ MockConsensusNode in subspace_test_service - Rust

Struct subspace_test_service::MockConsensusNode

source · 
pub struct MockConsensusNode {
     pub task_manager: TaskManager,
-    pub client: Arc<Client>,
-    pub backend: Arc<Backend>,
+    pub client: Arc<Client>,
+    pub backend: Arc<Backend>,
     pub executor: RuntimeExecutor,
-    pub transaction_pool: Arc<FullPool<Client, Block, Header>>,
+    pub transaction_pool: Arc<FullPool<Client, Block, Header>>,
     pub select_chain: FullSelectChain,
     pub network_service: Arc<NetworkService<Block, <Block as BlockT>::Hash>>,
     pub xdm_gossip_notification_service: Option<Box<dyn NotificationService>>,
@@ -14,10 +14,10 @@
     /* private fields */
 }
Expand description

A mock Subspace consensus node instance used for testing.

Fields§

§task_manager: TaskManager

TaskManager’s instance.

-
§client: Arc<Client>

Client’s instance.

-
§backend: Arc<Backend>

Backend.

+
§client: Arc<Client>

Client’s instance.

+
§backend: Arc<Backend>

Backend.

§executor: RuntimeExecutor

Code executor.

-
§transaction_pool: Arc<FullPool<Client, Block, Header>>

Transaction pool.

+
§transaction_pool: Arc<FullPool<Client, Block, Header>>

Transaction pool.

§select_chain: FullSelectChain

The SelectChain Strategy

§network_service: Arc<NetworkService<Block, <Block as BlockT>::Hash>>

Network service.

§xdm_gossip_notification_service: Option<Box<dyn NotificationService>>

Cross-domain gossip notification service.

diff --git a/trait.impl/scale_info/trait.TypeInfo.js b/trait.impl/scale_info/trait.TypeInfo.js index 366effed38..239092ec64 100644 --- a/trait.impl/scale_info/trait.TypeInfo.js +++ b/trait.impl/scale_info/trait.TypeInfo.js @@ -6,7 +6,7 @@ "orml_vesting":[["impl<BlockNumber, Balance> TypeInfo for VestingSchedule<BlockNumber, Balance>
where\n BlockNumber: TypeInfo + 'static,\n Balance: HasCompact + MaxEncodedLen + HasCompact + TypeInfo + 'static,
"],["impl<T> TypeInfo for Event<T>
where\n T::AccountId: TypeInfo + 'static,\n VestingSchedule<BlockNumberFor<T>, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static,\n <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n PhantomData<T>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n <T::Lookup as StaticLookup>::Source: TypeInfo + 'static,\n VestingSchedule<BlockNumberFor<T>, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static,\n Vec<VestingSchedule<BlockNumberFor<T>, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance>>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"]], "pallet_block_fees":[["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n T::Balance: HasCompact,\n T: Config + 'static,
"]], "pallet_domain_id":[["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n T: Config + 'static,
"]], -"pallet_domains":[["impl<AccountId> TypeInfo for DomainConfig<AccountId>
where\n OperatorAllowList<AccountId>: TypeInfo + 'static,\n AccountId: Ord + TypeInfo + 'static,
"],["impl TypeInfo for Error"],["impl<T> TypeInfo for Event<T>
where\n BlockNumberFor<T>: TypeInfo + 'static,\n <T as Config>::AccountId: TypeInfo + 'static,\n <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n Option<DomainBlockNumberFor<T>>: TypeInfo + 'static,\n SlashedReason<DomainBlockNumberFor<T>, ReceiptHashFor<T>>: TypeInfo + 'static,\n PhantomData<T>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl TypeInfo for BundleError"],["impl<Hash> TypeInfo for ScheduledRuntimeUpgrade<Hash>
where\n Hash: TypeInfo + 'static,
"],["impl TypeInfo for TxRangeState"],["impl TypeInfo for FraudProofError"],["impl TypeInfo for DomainRuntimeInfo"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for BlockTreeNode<Number, Hash, DomainNumber, DomainHash, Balance>
where\n ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainNumber: TypeInfo + 'static,\n DomainHash: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n OpaqueBundleOf<T>: TypeInfo + 'static,\n Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>: TypeInfo + 'static,\n <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n OperatorConfig<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static,\n DomainConfig<T::AccountId>: TypeInfo + 'static,\n T::Share: TypeInfo + 'static,\n OperatorAllowList<T::AccountId>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl TypeInfo for Error"],["impl TypeInfo for Error"],["impl<Number, ReceiptHash, AccountId> TypeInfo for DomainObject<Number, ReceiptHash, AccountId>
where\n AccountId: TypeInfo + 'static + Ord,\n Number: TypeInfo + 'static,\n ReceiptHash: TypeInfo + 'static,\n DomainConfig<AccountId>: TypeInfo + 'static,
"],["impl<Balance> TypeInfo for OperatorConfig<Balance>
where\n Balance: TypeInfo + 'static,
"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl<Number, Hash> TypeInfo for RuntimeObject<Number, Hash>
where\n Hash: TypeInfo + 'static,\n Number: TypeInfo + 'static,
"],["impl<DomainBlock, ReceiptHash> TypeInfo for SlashedReason<DomainBlock, ReceiptHash>
where\n DomainBlock: TypeInfo + 'static,\n ReceiptHash: TypeInfo + 'static,
"]], +"pallet_domains":[["impl<AccountId> TypeInfo for DomainConfig<AccountId>
where\n OperatorAllowList<AccountId>: TypeInfo + 'static,\n AccountId: Ord + TypeInfo + 'static,
"],["impl TypeInfo for Error"],["impl<T> TypeInfo for Event<T>
where\n BlockNumberFor<T>: TypeInfo + 'static,\n <T as Config>::AccountId: TypeInfo + 'static,\n <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n Option<DomainBlockNumberFor<T>>: TypeInfo + 'static,\n SlashedReason<DomainBlockNumberFor<T>, ReceiptHashFor<T>>: TypeInfo + 'static,\n PhantomData<T>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl TypeInfo for BundleError"],["impl<Hash> TypeInfo for ScheduledRuntimeUpgrade<Hash>
where\n Hash: TypeInfo + 'static,
"],["impl TypeInfo for TxRangeState"],["impl TypeInfo for FraudProofError"],["impl TypeInfo for DomainRuntimeInfo"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for BlockTreeNode<Number, Hash, DomainNumber, DomainHash, Balance>
where\n ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainNumber: TypeInfo + 'static,\n DomainHash: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n OpaqueBundleOf<T>: TypeInfo + 'static,\n Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>: TypeInfo + 'static,\n <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n OperatorConfig<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static,\n DomainConfig<T::AccountId>: TypeInfo + 'static,\n T::Share: TypeInfo + 'static,\n OperatorAllowList<T::AccountId>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl TypeInfo for Error"],["impl TypeInfo for Error"],["impl<Number, ReceiptHash, AccountId> TypeInfo for DomainObject<Number, ReceiptHash, AccountId>
where\n AccountId: TypeInfo + 'static + Ord,\n Number: TypeInfo + 'static,\n ReceiptHash: TypeInfo + 'static,\n DomainConfig<AccountId>: TypeInfo + 'static,
"],["impl<Balance> TypeInfo for OperatorConfig<Balance>
where\n Balance: TypeInfo + 'static,
"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl<Number, Hash> TypeInfo for RuntimeObject<Number, Hash>
where\n Hash: TypeInfo + 'static,\n Number: TypeInfo + 'static,
"],["impl<DomainBlock, ReceiptHash> TypeInfo for SlashedReason<DomainBlock, ReceiptHash>
where\n DomainBlock: TypeInfo + 'static,\n ReceiptHash: TypeInfo + 'static,
"]], "pallet_feeds":[["impl<T> TypeInfo for Event<T>
where\n T::FeedId: TypeInfo + 'static,\n T::AccountId: TypeInfo + 'static,\n PhantomData<T>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl TypeInfo for TotalObjectsAndSize"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n T::FeedProcessorKind: TypeInfo + 'static,\n T::FeedId: TypeInfo + 'static,\n <T::Lookup as StaticLookup>::Source: TypeInfo + 'static,\n T: Config + 'static,
"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl<FeedProcessorId, AccountId> TypeInfo for FeedConfig<FeedProcessorId, AccountId>
where\n FeedProcessorId: TypeInfo + 'static,\n AccountId: TypeInfo + 'static,
"]], "pallet_grandpa_finality_verifier":[["impl TypeInfo for InitializationData"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n T: Config + 'static,
"]], "pallet_messenger":[["impl<T> TypeInfo for Event<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n InitiateChannelParams<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static,\n CrossDomainMessage<BlockNumberFor<T>, T::Hash, <<T as Config>::Hashing as Hash>::Output>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl<Balance> TypeInfo for Channel<Balance>
where\n FeeModel<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl TypeInfo for ChannelState"],["impl TypeInfo for OutboxMessageResult"]], diff --git a/trait.impl/subspace_runtime_primitives/trait.FindBlockRewardAddress.js b/trait.impl/subspace_runtime_primitives/trait.FindBlockRewardAddress.js index 37b07885fb..84683eee36 100644 --- a/trait.impl/subspace_runtime_primitives/trait.FindBlockRewardAddress.js +++ b/trait.impl/subspace_runtime_primitives/trait.FindBlockRewardAddress.js @@ -1,3 +1,3 @@ (function() {var implementors = { -"pallet_subspace":[["impl<T: Config> FindBlockRewardAddress<<T as Config>::AccountId> for Pallet<T>"]] +"pallet_subspace":[["impl<T: Config> FindBlockRewardAddress<<T as Config>::AccountId> for Pallet<T>"]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/subspace_runtime_primitives/trait.FindVotingRewardAddresses.js b/trait.impl/subspace_runtime_primitives/trait.FindVotingRewardAddresses.js index 4d6604fe14..e535c8feac 100644 --- a/trait.impl/subspace_runtime_primitives/trait.FindVotingRewardAddresses.js +++ b/trait.impl/subspace_runtime_primitives/trait.FindVotingRewardAddresses.js @@ -1,3 +1,3 @@ (function() {var implementors = { -"pallet_subspace":[["impl<T: Config> FindVotingRewardAddresses<<T as Config>::AccountId> for Pallet<T>"]] +"pallet_subspace":[["impl<T: Config> FindVotingRewardAddresses<<T as Config>::AccountId> for Pallet<T>"]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/type.impl/pallet_domains/struct.Pallet.js b/type.impl/pallet_domains/struct.Pallet.js index d6f4d577ea..1f1db58caa 100644 --- a/type.impl/pallet_domains/struct.Pallet.js +++ b/type.impl/pallet_domains/struct.Pallet.js @@ -1,3 +1,3 @@ (function() {var type_impls = { -"pallet_domains":[["
source§

impl<T: Config> Pallet<T>

source

pub fn submit_bundle(\n origin: OriginFor<T>,\n opaque_bundle: OpaqueBundleOf<T>\n) -> DispatchResultWithPostInfo

source

pub fn submit_fraud_proof(\n origin: OriginFor<T>,\n fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>\n) -> DispatchResult

source

pub fn register_domain_runtime(\n origin: OriginFor<T>,\n runtime_name: String,\n runtime_type: RuntimeType,\n raw_genesis_storage: Vec<u8>\n) -> DispatchResult

source

pub fn upgrade_domain_runtime(\n origin: OriginFor<T>,\n runtime_id: RuntimeId,\n raw_genesis_storage: Vec<u8>\n) -> DispatchResult

source

pub fn register_operator(\n origin: OriginFor<T>,\n domain_id: DomainId,\n amount: <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance,\n config: OperatorConfig<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>\n) -> DispatchResult

source

pub fn nominate_operator(\n origin: OriginFor<T>,\n operator_id: OperatorId,\n amount: <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance\n) -> DispatchResult

source

pub fn instantiate_domain(\n origin: OriginFor<T>,\n domain_config: DomainConfig<T::AccountId>\n) -> DispatchResult

source

pub fn switch_domain(\n origin: OriginFor<T>,\n operator_id: OperatorId,\n new_domain_id: DomainId\n) -> DispatchResult

source

pub fn deregister_operator(\n origin: OriginFor<T>,\n operator_id: OperatorId\n) -> DispatchResult

source

pub fn withdraw_stake(\n origin: OriginFor<T>,\n operator_id: OperatorId,\n shares: T::Share\n) -> DispatchResult

source

pub fn unlock_funds(\n origin: OriginFor<T>,\n operator_id: OperatorId\n) -> DispatchResult

Unlocks the first withdrawal given the unlocking period is complete.\nEven if rest of the withdrawals are out of unlocking period, nominator\nshould call this extrinsic to unlock each withdrawal

\n
source

pub fn unlock_operator(\n origin: OriginFor<T>,\n operator_id: OperatorId\n) -> DispatchResult

Unlocks the operator given the unlocking period is complete.\nAnyone can initiate the operator unlock.

\n
source

pub fn update_domain_operator_allow_list(\n origin: OriginFor<T>,\n domain_id: DomainId,\n operator_allow_list: OperatorAllowList<T::AccountId>\n) -> DispatchResult

Extrinsic to update domain’s operator allow list.\nNote:

\n
    \n
  • If the previous allowed list is set to specific operators and new allow list is set\nto Anyone, then domain will become permissioned to open for all operators.
    • \n
  • If the previous allowed list is set to Anyone or specific operators and the new\nallow list is set to specific operators, then all the registered not allowed operators\nwill continue to operate until they de-register themselves.
    • \n
\n
source

pub fn force_staking_epoch_transition(\n origin: OriginFor<T>,\n domain_id: DomainId\n) -> DispatchResult

Force staking epoch transition for a given domain

\n
",0,"pallet_domains::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn operator_signing_key<KArg>(k: KArg) -> Option<OperatorId>
where\n KArg: EncodeLike<OperatorPublicKey>,

An auto-generated getter for OperatorSigningKey.

\n
",0,"pallet_domains::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn domain_staking_summary<KArg>(\n k: KArg\n) -> Option<StakingSummary<OperatorId, <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>>
where\n KArg: EncodeLike<DomainId>,

An auto-generated getter for DomainStakingSummary.

\n
",0,"pallet_domains::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn consensus_block_info<KArg1, KArg2>(\n k1: KArg1,\n k2: KArg2\n) -> Option<T::Hash>
where\n KArg1: EncodeLike<DomainId>,\n KArg2: EncodeLike<BlockNumberFor<T>>,

An auto-generated getter for ConsensusBlockHash.

\n
",0,"pallet_domains::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn successful_bundles(domain_id: DomainId) -> Vec<H256>

source

pub fn successful_fraud_proofs(domain_id: DomainId) -> Vec<T::DomainHash>

source

pub fn domain_runtime_code(domain_id: DomainId) -> Option<Vec<u8>>

source

pub fn domain_best_number(\n domain_id: DomainId\n) -> Option<DomainBlockNumberFor<T>>

source

pub fn domain_state_root(\n domain_id: DomainId,\n domain_block_number: DomainBlockNumberFor<T>,\n domain_block_hash: T::DomainHash\n) -> Option<T::DomainHash>

source

pub fn runtime_id(domain_id: DomainId) -> Option<RuntimeId>

source

pub fn domain_instance_data(\n domain_id: DomainId\n) -> Option<(DomainInstanceData, BlockNumberFor<T>)>

source

pub fn genesis_state_root(domain_id: DomainId) -> Option<H256>

source

pub fn domain_tx_range(domain_id: DomainId) -> U256

Returns the tx range for the domain.

\n
source

pub fn bundle_producer_election_params(\n domain_id: DomainId\n) -> Option<BundleProducerElectionParams<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>>

source

pub fn operator(\n operator_id: OperatorId\n) -> Option<(OperatorPublicKey, <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance)>

source

pub fn head_receipt_number(domain_id: DomainId) -> DomainBlockNumberFor<T>

Returns the best execution chain number.

\n
source

pub fn oldest_unconfirmed_receipt_number(\n domain_id: DomainId\n) -> Option<DomainBlockNumberFor<T>>

Returns the block number of the oldest existing unconfirmed execution receipt, return None\nmeans there is no unconfirmed ER exist or submitted yet.

\n
source

pub fn domain_block_limit(domain_id: DomainId) -> Option<DomainBlockLimit>

Returns the domain block limit of the given domain.

\n
source

pub fn non_empty_er_exists(domain_id: DomainId) -> bool

Returns if there are any ERs in the challenge period that have non empty extrinsics.\nNote that Genesis ER is also considered special and hence non empty

\n
source

pub fn extrinsics_shuffling_seed() -> T::Hash

source

pub fn execution_receipt(\n receipt_hash: ReceiptHashFor<T>\n) -> Option<ExecutionReceiptOf<T>>

source

pub fn receipt_hash(\n domain_id: DomainId,\n domain_number: DomainBlockNumberFor<T>\n) -> Option<ReceiptHashFor<T>>

",0,"pallet_domains::pallet::Module"],["
source§

impl<T> Pallet<T>
where\n T: Config + SendTransactionTypes<Call<T>>,

source

pub fn submit_bundle_unsigned(opaque_bundle: OpaqueBundleOf<T>)

Submits an unsigned extrinsic Call::submit_bundle.

\n
source

pub fn submit_fraud_proof_unsigned(\n fraud_proof: FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>\n)

Submits an unsigned extrinsic Call::submit_fraud_proof.

\n
",0,"pallet_domains::pallet::Module"],["
source§

impl<T: Config> StorageInfoTrait for Pallet<T>

source§

fn storage_info() -> Vec<StorageInfo>

","StorageInfoTrait","pallet_domains::pallet::Module"],["
source§

impl<T> Eq for Pallet<T>

","Eq","pallet_domains::pallet::Module"],["
source§

impl<T: Config> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(block_number: BlockNumberFor<T>) -> Weight

Block initialization hook. This is called at the very beginning of block execution. Read more
source§

fn on_finalize(_: BlockNumberFor<T>)

Block finalization hook. This is called at the very end of block execution. Read more
§

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before\n[Hooks::on_finalize]). Read more
§

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by FRAME. Read more
§

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are\ndispatched as separate threads, and entirely independent of the main wasm runtime. Read more
§

fn integrity_test()

Check the integrity of this pallet’s configuration. Read more
","Hooks<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_domains::pallet::Module"],["
source§

impl<T: Config> PalletInfoAccess for Pallet<T>

source§

fn index() -> usize

Index of the pallet as configured in the runtime.
source§

fn name() -> &'static str

Name of the pallet as configured in the runtime.
source§

fn name_hash() -> [u8; 16]

Two128 hash of name.
source§

fn module_name() -> &'static str

Name of the Rust module containing the pallet.
source§

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.
","PalletInfoAccess","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_finalize(n: BlockNumberFor<T>)

See [Hooks::on_finalize].
","OnFinalize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_domains::pallet::Module"],["
source§

impl<T: Config> WhitelistedStorageKeys for Pallet<T>

source§

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

Returns a Vec<TrackedStorageKey> indicating the storage keys that\nshould be whitelisted during benchmarking. This means that those keys\nwill be excluded from the benchmarking performance calculation.
","WhitelistedStorageKeys","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OnRuntimeUpgrade for Pallet<T>

source§

fn on_runtime_upgrade() -> Weight

See [Hooks::on_runtime_upgrade].
","OnRuntimeUpgrade","pallet_domains::pallet::Module"],["
source§

impl<T: Config> Callable<T> for Pallet<T>

§

type RuntimeCall = Call<T>

","Callable","pallet_domains::pallet::Module"],["
source§

impl<T> Debug for Pallet<T>

source§

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

Formats the value using the given formatter. Read more
","Debug","pallet_domains::pallet::Module"],["
source§

impl<T: Config> IntegrityTest for Pallet<T>

source§

fn integrity_test()

See [Hooks::integrity_test].
","IntegrityTest","pallet_domains::pallet::Module"],["
source§

impl<T: Config> ValidateUnsigned for Pallet<T>

§

type Call = Call<T>

The call to validate
source§

fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError>

Validate the call right before dispatch. Read more
source§

fn validate_unsigned(\n _source: TransactionSource,\n call: &Self::Call\n) -> TransactionValidity

Return the validity of the call Read more
","ValidateUnsigned","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn offchain_worker(n: BlockNumberFor<T>)

This function is being called after every block import (when fully synced). Read more
","OffchainWorker<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_idle(n: BlockNumberFor<T>, remaining_weight: Weight) -> Weight

See [Hooks::on_idle].
","OnIdle<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_domains::pallet::Module"],["
source§

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
","Clone","pallet_domains::pallet::Module"],["
source§

impl<T: Config> BeforeAllRuntimeMigrations for Pallet<T>

source§

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.
","BeforeAllRuntimeMigrations","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(n: BlockNumberFor<T>) -> Weight

See [Hooks::on_initialize].
","OnInitialize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_domains::pallet::Module"],["
source§

impl<T: Config> GetStorageVersion for Pallet<T>

§

type CurrentStorageVersion = StorageVersion

This will be filled out by the pallet macro. Read more
source§

fn current_storage_version() -> Self::CurrentStorageVersion

Returns the current storage version as supported by the pallet.
source§

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.
","GetStorageVersion","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OnGenesis for Pallet<T>

source§

fn on_genesis()

Something that should happen at genesis.
","OnGenesis","pallet_domains::pallet::Module"],["
source§

impl<T: Config> PalletsInfoAccess for Pallet<T>

source§

fn count() -> usize

The number of pallets’ information that this type represents. Read more
source§

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.
","PalletsInfoAccess","pallet_domains::pallet::Module"],["
source§

impl<T> PartialEq for Pallet<T>

source§

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

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","pallet_domains::pallet::Module"]] +"pallet_domains":[["
source§

impl<T: Config> Pallet<T>

source

pub fn submit_bundle(\n origin: OriginFor<T>,\n opaque_bundle: OpaqueBundleOf<T>\n) -> DispatchResultWithPostInfo

source

pub fn submit_fraud_proof(\n origin: OriginFor<T>,\n fraud_proof: Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>\n) -> DispatchResult

source

pub fn register_domain_runtime(\n origin: OriginFor<T>,\n runtime_name: String,\n runtime_type: RuntimeType,\n raw_genesis_storage: Vec<u8>\n) -> DispatchResult

source

pub fn upgrade_domain_runtime(\n origin: OriginFor<T>,\n runtime_id: RuntimeId,\n raw_genesis_storage: Vec<u8>\n) -> DispatchResult

source

pub fn register_operator(\n origin: OriginFor<T>,\n domain_id: DomainId,\n amount: <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance,\n config: OperatorConfig<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>\n) -> DispatchResult

source

pub fn nominate_operator(\n origin: OriginFor<T>,\n operator_id: OperatorId,\n amount: <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance\n) -> DispatchResult

source

pub fn instantiate_domain(\n origin: OriginFor<T>,\n domain_config: DomainConfig<T::AccountId>\n) -> DispatchResult

source

pub fn switch_domain(\n origin: OriginFor<T>,\n operator_id: OperatorId,\n new_domain_id: DomainId\n) -> DispatchResult

source

pub fn deregister_operator(\n origin: OriginFor<T>,\n operator_id: OperatorId\n) -> DispatchResult

source

pub fn withdraw_stake(\n origin: OriginFor<T>,\n operator_id: OperatorId,\n shares: T::Share\n) -> DispatchResult

source

pub fn unlock_funds(\n origin: OriginFor<T>,\n operator_id: OperatorId\n) -> DispatchResult

Unlocks the first withdrawal given the unlocking period is complete.\nEven if rest of the withdrawals are out of unlocking period, nominator\nshould call this extrinsic to unlock each withdrawal

\n
source

pub fn unlock_operator(\n origin: OriginFor<T>,\n operator_id: OperatorId\n) -> DispatchResult

Unlocks the operator given the unlocking period is complete.\nAnyone can initiate the operator unlock.

\n
source

pub fn update_domain_operator_allow_list(\n origin: OriginFor<T>,\n domain_id: DomainId,\n operator_allow_list: OperatorAllowList<T::AccountId>\n) -> DispatchResult

Extrinsic to update domain’s operator allow list.\nNote:

\n
    \n
  • If the previous allowed list is set to specific operators and new allow list is set\nto Anyone, then domain will become permissioned to open for all operators.
    • \n
  • If the previous allowed list is set to Anyone or specific operators and the new\nallow list is set to specific operators, then all the registered not allowed operators\nwill continue to operate until they de-register themselves.
    • \n
\n
source

pub fn force_staking_epoch_transition(\n origin: OriginFor<T>,\n domain_id: DomainId\n) -> DispatchResult

Force staking epoch transition for a given domain

\n
",0,"pallet_domains::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn operator_signing_key<KArg>(k: KArg) -> Option<OperatorId>
where\n KArg: EncodeLike<OperatorPublicKey>,

An auto-generated getter for OperatorSigningKey.

\n
",0,"pallet_domains::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn domain_staking_summary<KArg>(\n k: KArg\n) -> Option<StakingSummary<OperatorId, <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>>
where\n KArg: EncodeLike<DomainId>,

An auto-generated getter for DomainStakingSummary.

\n
",0,"pallet_domains::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn consensus_block_info<KArg1, KArg2>(\n k1: KArg1,\n k2: KArg2\n) -> Option<T::Hash>
where\n KArg1: EncodeLike<DomainId>,\n KArg2: EncodeLike<BlockNumberFor<T>>,

An auto-generated getter for ConsensusBlockHash.

\n
",0,"pallet_domains::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn successful_bundles(domain_id: DomainId) -> Vec<H256>

source

pub fn successful_fraud_proofs(domain_id: DomainId) -> Vec<T::DomainHash>

source

pub fn domain_runtime_code(domain_id: DomainId) -> Option<Vec<u8>>

source

pub fn domain_best_number(\n domain_id: DomainId\n) -> Option<DomainBlockNumberFor<T>>

source

pub fn domain_state_root(\n domain_id: DomainId,\n domain_block_number: DomainBlockNumberFor<T>,\n domain_block_hash: T::DomainHash\n) -> Option<T::DomainHash>

source

pub fn runtime_id(domain_id: DomainId) -> Option<RuntimeId>

source

pub fn domain_instance_data(\n domain_id: DomainId\n) -> Option<(DomainInstanceData, BlockNumberFor<T>)>

source

pub fn genesis_state_root(domain_id: DomainId) -> Option<H256>

source

pub fn domain_tx_range(domain_id: DomainId) -> U256

Returns the tx range for the domain.

\n
source

pub fn bundle_producer_election_params(\n domain_id: DomainId\n) -> Option<BundleProducerElectionParams<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>>

source

pub fn operator(\n operator_id: OperatorId\n) -> Option<(OperatorPublicKey, <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance)>

source

pub fn head_receipt_number(domain_id: DomainId) -> DomainBlockNumberFor<T>

Returns the best execution chain number.

\n
source

pub fn oldest_unconfirmed_receipt_number(\n domain_id: DomainId\n) -> Option<DomainBlockNumberFor<T>>

Returns the block number of the oldest existing unconfirmed execution receipt, return None\nmeans there is no unconfirmed ER exist or submitted yet.

\n
source

pub fn domain_block_limit(domain_id: DomainId) -> Option<DomainBlockLimit>

Returns the domain block limit of the given domain.

\n
source

pub fn non_empty_er_exists(domain_id: DomainId) -> bool

Returns if there are any ERs in the challenge period that have non empty extrinsics.\nNote that Genesis ER is also considered special and hence non empty

\n
source

pub fn extrinsics_shuffling_seed() -> T::Hash

source

pub fn execution_receipt(\n receipt_hash: ReceiptHashFor<T>\n) -> Option<ExecutionReceiptOf<T>>

source

pub fn receipt_hash(\n domain_id: DomainId,\n domain_number: DomainBlockNumberFor<T>\n) -> Option<ReceiptHashFor<T>>

",0,"pallet_domains::pallet::Module"],["
source§

impl<T> Pallet<T>
where\n T: Config + SendTransactionTypes<Call<T>>,

source

pub fn submit_bundle_unsigned(opaque_bundle: OpaqueBundleOf<T>)

Submits an unsigned extrinsic Call::submit_bundle.

\n
source

pub fn submit_fraud_proof_unsigned(\n fraud_proof: FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>\n)

Submits an unsigned extrinsic Call::submit_fraud_proof.

\n
",0,"pallet_domains::pallet::Module"],["
source§

impl<T: Config> StorageInfoTrait for Pallet<T>

source§

fn storage_info() -> Vec<StorageInfo>

","StorageInfoTrait","pallet_domains::pallet::Module"],["
source§

impl<T> Eq for Pallet<T>

","Eq","pallet_domains::pallet::Module"],["
source§

impl<T: Config> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(block_number: BlockNumberFor<T>) -> Weight

Block initialization hook. This is called at the very beginning of block execution. Read more
source§

fn on_finalize(_: BlockNumberFor<T>)

Block finalization hook. This is called at the very end of block execution. Read more
§

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before\n[Hooks::on_finalize]). Read more
§

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by FRAME. Read more
§

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are\ndispatched as separate threads, and entirely independent of the main wasm runtime. Read more
§

fn integrity_test()

Check the integrity of this pallet’s configuration. Read more
","Hooks<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_domains::pallet::Module"],["
source§

impl<T: Config> PalletInfoAccess for Pallet<T>

source§

fn index() -> usize

Index of the pallet as configured in the runtime.
source§

fn name() -> &'static str

Name of the pallet as configured in the runtime.
source§

fn name_hash() -> [u8; 16]

Two128 hash of name.
source§

fn module_name() -> &'static str

Name of the Rust module containing the pallet.
source§

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.
","PalletInfoAccess","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_finalize(n: BlockNumberFor<T>)

See [Hooks::on_finalize].
","OnFinalize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_domains::pallet::Module"],["
source§

impl<T: Config> WhitelistedStorageKeys for Pallet<T>

source§

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

Returns a Vec<TrackedStorageKey> indicating the storage keys that\nshould be whitelisted during benchmarking. This means that those keys\nwill be excluded from the benchmarking performance calculation.
","WhitelistedStorageKeys","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OnRuntimeUpgrade for Pallet<T>

source§

fn on_runtime_upgrade() -> Weight

See [Hooks::on_runtime_upgrade].
","OnRuntimeUpgrade","pallet_domains::pallet::Module"],["
source§

impl<T: Config> Callable<T> for Pallet<T>

§

type RuntimeCall = Call<T>

","Callable","pallet_domains::pallet::Module"],["
source§

impl<T> Debug for Pallet<T>

source§

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

Formats the value using the given formatter. Read more
","Debug","pallet_domains::pallet::Module"],["
source§

impl<T: Config> IntegrityTest for Pallet<T>

source§

fn integrity_test()

See [Hooks::integrity_test].
","IntegrityTest","pallet_domains::pallet::Module"],["
source§

impl<T: Config> ValidateUnsigned for Pallet<T>

§

type Call = Call<T>

The call to validate
source§

fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError>

Validate the call right before dispatch. Read more
source§

fn validate_unsigned(\n _source: TransactionSource,\n call: &Self::Call\n) -> TransactionValidity

Return the validity of the call Read more
","ValidateUnsigned","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn offchain_worker(n: BlockNumberFor<T>)

This function is being called after every block import (when fully synced). Read more
","OffchainWorker<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_idle(n: BlockNumberFor<T>, remaining_weight: Weight) -> Weight

See [Hooks::on_idle].
","OnIdle<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_domains::pallet::Module"],["
source§

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
","Clone","pallet_domains::pallet::Module"],["
source§

impl<T: Config> BeforeAllRuntimeMigrations for Pallet<T>

source§

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.
","BeforeAllRuntimeMigrations","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(n: BlockNumberFor<T>) -> Weight

See [Hooks::on_initialize].
","OnInitialize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_domains::pallet::Module"],["
source§

impl<T: Config> GetStorageVersion for Pallet<T>

§

type CurrentStorageVersion = StorageVersion

This will be filled out by the pallet macro. Read more
source§

fn current_storage_version() -> Self::CurrentStorageVersion

Returns the current storage version as supported by the pallet.
source§

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.
","GetStorageVersion","pallet_domains::pallet::Module"],["
source§

impl<T: Config> OnGenesis for Pallet<T>

source§

fn on_genesis()

Something that should happen at genesis.
","OnGenesis","pallet_domains::pallet::Module"],["
source§

impl<T: Config> PalletsInfoAccess for Pallet<T>

source§

fn count() -> usize

The number of pallets’ information that this type represents. Read more
source§

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.
","PalletsInfoAccess","pallet_domains::pallet::Module"],["
source§

impl<T> PartialEq for Pallet<T>

source§

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

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","pallet_domains::pallet::Module"]] };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})() \ No newline at end of file diff --git a/type.impl/pallet_subspace/pallet/struct.Pallet.js b/type.impl/pallet_subspace/pallet/struct.Pallet.js index 086a7cec22..b99ffcddc1 100644 --- a/type.impl/pallet_subspace/pallet/struct.Pallet.js +++ b/type.impl/pallet_subspace/pallet/struct.Pallet.js @@ -1,5 +1,5 @@ (function() {var type_impls = { -"pallet_subspace":[["
source§

impl<T: Config> Pallet<T>

Methods for the ValidateUnsigned implementation:\nIt restricts calls to report_equivocation to local calls (i.e. extrinsics generated on this\nnode) or that already in a block. This guarantees that only block authors can include\nequivocation reports.

\n
source

pub fn validate_equivocation_report(\n source: TransactionSource,\n equivocation_proof: &EquivocationProof<HeaderFor<T>>\n) -> TransactionValidity

source

pub fn pre_dispatch_equivocation_report(\n equivocation_proof: &EquivocationProof<HeaderFor<T>>\n) -> Result<(), TransactionValidityError>

",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn report_equivocation(\n origin: OriginFor<T>,\n equivocation_proof: Box<EquivocationProof<HeaderFor<T>>>\n) -> DispatchResultWithPostInfo

Report farmer equivocation/misbehavior. This method will verify the equivocation proof.\nIf valid, the offence will be reported.

\n

This extrinsic must be called unsigned and it is expected that only block authors will\ncall it (validated in ValidateUnsigned), as such if the block author is defined it\nwill be defined as the equivocation reporter.

\n
source

pub fn store_segment_headers(\n origin: OriginFor<T>,\n segment_headers: Vec<SegmentHeader>\n) -> DispatchResult

Submit new segment header to the blockchain. This is an inherent extrinsic and part of\nthe Subspace consensus logic.

\n
source

pub fn enable_solution_range_adjustment(\n origin: OriginFor<T>,\n solution_range_override: Option<u64>,\n voting_solution_range_override: Option<u64>\n) -> DispatchResult

Enable solution range adjustment after every era.\nNote: No effect on the solution range for the current era

\n
source

pub fn vote(\n origin: OriginFor<T>,\n signed_vote: Box<SignedVote<BlockNumberFor<T>, T::Hash, T::AccountId>>\n) -> DispatchResult

Farmer vote, currently only used for extra rewards to farmers.

\n
source

pub fn enable_rewards_at(\n origin: OriginFor<T>,\n enable_rewards_at: EnableRewardsAt<BlockNumberFor<T>>\n) -> DispatchResult

Enable rewards for blocks and votes at specified block height.

\n
source

pub fn enable_authoring_by_anyone(origin: OriginFor<T>) -> DispatchResult

Enable storage access for all users.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn genesis_slot() -> Slot

An auto-generated getter for GenesisSlot.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn current_slot() -> Slot

An auto-generated getter for CurrentSlot.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn solution_ranges() -> SolutionRanges

An auto-generated getter for SolutionRanges.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn should_adjust_solution_range() -> bool

An auto-generated getter for ShouldAdjustSolutionRange.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn segment_commitment<KArg>(k: KArg) -> Option<SegmentCommitment>
where\n KArg: EncodeLike<SegmentIndex>,

An auto-generated getter for SegmentCommitment.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn root_plot_public_key() -> Option<FarmerPublicKey>

An auto-generated getter for RootPlotPublicKey.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn history_size() -> HistorySize

Total number of pieces in the blockchain

\n
source

pub fn submit_equivocation_report(\n equivocation_proof: EquivocationProof<HeaderFor<T>>\n) -> Option<()>

Submits an extrinsic to report an equivocation. This method will create an unsigned\nextrinsic with a call to report_equivocation and will push the transaction to the pool.\nOnly useful in an offchain context.

\n
source

pub fn submit_test_equivocation_report(\n equivocation_proof: EquivocationProof<HeaderFor<T>>\n) -> Option<()>

Just stores offender from equivocation report in block list, only used for tests.

\n
source

pub fn pot_parameters() -> PotParameters

Proof of time parameters

\n
source

pub fn is_in_block_list(farmer_public_key: &FarmerPublicKey) -> bool

Check if farmer_public_key is in block list (due to equivocation)

\n
source

pub fn archived_history_size() -> u64

Size of the archived history of the blockchain in bytes

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T> Pallet<T>
where\n T: Config + SendTransactionTypes<Call<T>>,

source

pub fn submit_vote(\n signed_vote: SignedVote<BlockNumberFor<T>, T::Hash, T::AccountId>\n)

Submit farmer vote vote that is essentially a header with bigger solution range than\nacceptable for block authoring.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Callable<T> for Pallet<T>

§

type RuntimeCall = Call<T>

","Callable","pallet_subspace::pallet::Module"],["
source§

impl<T> PartialEq for Pallet<T>

source§

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

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> ValidateUnsigned for Pallet<T>

§

type Call = Call<T>

The call to validate
source§

fn validate_unsigned(\n source: TransactionSource,\n call: &Self::Call\n) -> TransactionValidity

Return the validity of the call Read more
source§

fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError>

Validate the call right before dispatch. Read more
","ValidateUnsigned","pallet_subspace::pallet::Module"],["
source§

impl<T> Debug for Pallet<T>

source§

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

Formats the value using the given formatter. Read more
","Debug","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Randomness<<T as Config>::Hash, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn random(subject: &[u8]) -> (T::Hash, BlockNumberFor<T>)

Get the most recently determined random seed, along with the time in the past\nsince when it was determinable by chain observers. Read more
source§

fn random_seed() -> (T::Hash, BlockNumberFor<T>)

Get the basic random seed. Read more
","Randomness<::Hash, <<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> PalletInfoAccess for Pallet<T>

source§

fn index() -> usize

Index of the pallet as configured in the runtime.
source§

fn name() -> &'static str

Name of the pallet as configured in the runtime.
source§

fn name_hash() -> [u8; 16]

Two128 hash of name.
source§

fn module_name() -> &'static str

Name of the Rust module containing the pallet.
source§

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.
","PalletInfoAccess","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> BeforeAllRuntimeMigrations for Pallet<T>

source§

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.
","BeforeAllRuntimeMigrations","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_idle(n: BlockNumberFor<T>, remaining_weight: Weight) -> Weight

See [Hooks::on_idle].
","OnIdle<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(block_number: BlockNumberFor<T>) -> Weight

Block initialization hook. This is called at the very beginning of block execution. Read more
source§

fn on_finalize(block_number: BlockNumberFor<T>)

Block finalization hook. This is called at the very end of block execution. Read more
§

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before\n[Hooks::on_finalize]). Read more
§

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by FRAME. Read more
§

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are\ndispatched as separate threads, and entirely independent of the main wasm runtime. Read more
§

fn integrity_test()

Check the integrity of this pallet’s configuration. Read more
","Hooks<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> ProvideInherent for Pallet<T>

§

type Call = Call<T>

The call type of the pallet.
§

type Error = InherentError

The error returned by check_inherent.
source§

const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER

The inherent identifier used by this inherent.
source§

fn create_inherent(data: &InherentData) -> Option<Self::Call>

Create an inherent out of the given InherentData. Read more
source§

fn is_inherent_required(\n data: &InherentData\n) -> Result<Option<Self::Error>, Self::Error>

Determines whether this inherent is required in this block. Read more
source§

fn check_inherent(\n call: &Self::Call,\n data: &InherentData\n) -> Result<(), Self::Error>

Check whether the given inherent is valid. Checking the inherent is optional and can be\nomitted by using the default implementation. Read more
source§

fn is_inherent(call: &Self::Call) -> bool

Return whether the call is an inherent call. Read more
","ProvideInherent","pallet_subspace::pallet::Module"],["
source§

impl<T> Eq for Pallet<T>

","Eq","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> StorageInfoTrait for Pallet<T>

source§

fn storage_info() -> Vec<StorageInfo>

","StorageInfoTrait","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> FindVotingRewardAddresses<<T as Config>::AccountId> for Pallet<T>

source§

fn find_voting_reward_addresses() -> Vec<T::AccountId>

Find the addresses for voting rewards based on transactions found in the block.
","FindVotingRewardAddresses<::AccountId>","pallet_subspace::pallet::Module"],["
source§

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
","Clone","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> FindBlockRewardAddress<<T as Config>::AccountId> for Pallet<T>

source§

fn find_block_reward_address() -> Option<T::AccountId>

Find the address for a block rewards based on the pre-runtime digests.
","FindBlockRewardAddress<::AccountId>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnGenesis for Pallet<T>

source§

fn on_genesis()

Something that should happen at genesis.
","OnGenesis","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> WhitelistedStorageKeys for Pallet<T>

source§

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

Returns a Vec<TrackedStorageKey> indicating the storage keys that\nshould be whitelisted during benchmarking. This means that those keys\nwill be excluded from the benchmarking performance calculation.
","WhitelistedStorageKeys","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnRuntimeUpgrade for Pallet<T>

source§

fn on_runtime_upgrade() -> Weight

See [Hooks::on_runtime_upgrade].
","OnRuntimeUpgrade","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> PalletsInfoAccess for Pallet<T>

source§

fn count() -> usize

The number of pallets’ information that this type represents. Read more
source§

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.
","PalletsInfoAccess","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnOffenceHandler<Public> for Pallet<T>

source§

fn on_offence(offenders: &[OffenceDetails<FarmerPublicKey>])

A handler for an offence of a particular kind. Read more
","OnOffenceHandler","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> IntegrityTest for Pallet<T>

source§

fn integrity_test()

See [Hooks::integrity_test].
","IntegrityTest","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(n: BlockNumberFor<T>) -> Weight

See [Hooks::on_initialize].
","OnInitialize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn offchain_worker(n: BlockNumberFor<T>)

This function is being called after every block import (when fully synced). Read more
","OffchainWorker<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> GetStorageVersion for Pallet<T>

§

type CurrentStorageVersion = NoStorageVersionSet

This will be filled out by the pallet macro. Read more
source§

fn current_storage_version() -> Self::CurrentStorageVersion

Returns the current storage version as supported by the pallet.
source§

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.
","GetStorageVersion","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_finalize(n: BlockNumberFor<T>)

See [Hooks::on_finalize].
","OnFinalize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"]], +"pallet_subspace":[["
source§

impl<T: Config> Pallet<T>

Methods for the ValidateUnsigned implementation:\nIt restricts calls to report_equivocation to local calls (i.e. extrinsics generated on this\nnode) or that already in a block. This guarantees that only block authors can include\nequivocation reports.

\n
source

pub fn validate_equivocation_report(\n source: TransactionSource,\n equivocation_proof: &EquivocationProof<HeaderFor<T>>\n) -> TransactionValidity

source

pub fn pre_dispatch_equivocation_report(\n equivocation_proof: &EquivocationProof<HeaderFor<T>>\n) -> Result<(), TransactionValidityError>

",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn report_equivocation(\n origin: OriginFor<T>,\n equivocation_proof: Box<EquivocationProof<HeaderFor<T>>>\n) -> DispatchResultWithPostInfo

Report farmer equivocation/misbehavior. This method will verify the equivocation proof.\nIf valid, the offence will be reported.

\n

This extrinsic must be called unsigned and it is expected that only block authors will\ncall it (validated in ValidateUnsigned), as such if the block author is defined it\nwill be defined as the equivocation reporter.

\n
source

pub fn store_segment_headers(\n origin: OriginFor<T>,\n segment_headers: Vec<SegmentHeader>\n) -> DispatchResult

Submit new segment header to the blockchain. This is an inherent extrinsic and part of\nthe Subspace consensus logic.

\n
source

pub fn enable_solution_range_adjustment(\n origin: OriginFor<T>,\n solution_range_override: Option<u64>,\n voting_solution_range_override: Option<u64>\n) -> DispatchResult

Enable solution range adjustment after every era.\nNote: No effect on the solution range for the current era

\n
source

pub fn vote(\n origin: OriginFor<T>,\n signed_vote: Box<SignedVote<BlockNumberFor<T>, T::Hash, T::AccountId>>\n) -> DispatchResult

Farmer vote, currently only used for extra rewards to farmers.

\n
source

pub fn enable_rewards_at(\n origin: OriginFor<T>,\n enable_rewards_at: EnableRewardsAt<BlockNumberFor<T>>\n) -> DispatchResult

Enable rewards for blocks and votes at specified block height.

\n
source

pub fn enable_authoring_by_anyone(origin: OriginFor<T>) -> DispatchResult

Enable storage access for all users.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn genesis_slot() -> Slot

An auto-generated getter for GenesisSlot.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn current_slot() -> Slot

An auto-generated getter for CurrentSlot.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn solution_ranges() -> SolutionRanges

An auto-generated getter for SolutionRanges.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn should_adjust_solution_range() -> bool

An auto-generated getter for ShouldAdjustSolutionRange.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn segment_commitment<KArg>(k: KArg) -> Option<SegmentCommitment>
where\n KArg: EncodeLike<SegmentIndex>,

An auto-generated getter for SegmentCommitment.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn root_plot_public_key() -> Option<FarmerPublicKey>

An auto-generated getter for RootPlotPublicKey.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Pallet<T>

source

pub fn history_size() -> HistorySize

Total number of pieces in the blockchain

\n
source

pub fn submit_equivocation_report(\n equivocation_proof: EquivocationProof<HeaderFor<T>>\n) -> Option<()>

Submits an extrinsic to report an equivocation. This method will create an unsigned\nextrinsic with a call to report_equivocation and will push the transaction to the pool.\nOnly useful in an offchain context.

\n
source

pub fn submit_test_equivocation_report(\n equivocation_proof: EquivocationProof<HeaderFor<T>>\n) -> Option<()>

Just stores offender from equivocation report in block list, only used for tests.

\n
source

pub fn pot_parameters() -> PotParameters

Proof of time parameters

\n
source

pub fn is_in_block_list(farmer_public_key: &FarmerPublicKey) -> bool

Check if farmer_public_key is in block list (due to equivocation)

\n
source

pub fn archived_history_size() -> u64

Size of the archived history of the blockchain in bytes

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T> Pallet<T>
where\n T: Config + SendTransactionTypes<Call<T>>,

source

pub fn submit_vote(\n signed_vote: SignedVote<BlockNumberFor<T>, T::Hash, T::AccountId>\n)

Submit farmer vote vote that is essentially a header with bigger solution range than\nacceptable for block authoring.

\n
",0,"pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Callable<T> for Pallet<T>

§

type RuntimeCall = Call<T>

","Callable","pallet_subspace::pallet::Module"],["
source§

impl<T> PartialEq for Pallet<T>

source§

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

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> ValidateUnsigned for Pallet<T>

§

type Call = Call<T>

The call to validate
source§

fn validate_unsigned(\n source: TransactionSource,\n call: &Self::Call\n) -> TransactionValidity

Return the validity of the call Read more
source§

fn pre_dispatch(call: &Self::Call) -> Result<(), TransactionValidityError>

Validate the call right before dispatch. Read more
","ValidateUnsigned","pallet_subspace::pallet::Module"],["
source§

impl<T> Debug for Pallet<T>

source§

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

Formats the value using the given formatter. Read more
","Debug","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Randomness<<T as Config>::Hash, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn random(subject: &[u8]) -> (T::Hash, BlockNumberFor<T>)

Get the most recently determined random seed, along with the time in the past\nsince when it was determinable by chain observers. Read more
source§

fn random_seed() -> (T::Hash, BlockNumberFor<T>)

Get the basic random seed. Read more
","Randomness<::Hash, <<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> PalletInfoAccess for Pallet<T>

source§

fn index() -> usize

Index of the pallet as configured in the runtime.
source§

fn name() -> &'static str

Name of the pallet as configured in the runtime.
source§

fn name_hash() -> [u8; 16]

Two128 hash of name.
source§

fn module_name() -> &'static str

Name of the Rust module containing the pallet.
source§

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.
","PalletInfoAccess","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> BeforeAllRuntimeMigrations for Pallet<T>

source§

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.
","BeforeAllRuntimeMigrations","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_idle(n: BlockNumberFor<T>, remaining_weight: Weight) -> Weight

See [Hooks::on_idle].
","OnIdle<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(block_number: BlockNumberFor<T>) -> Weight

Block initialization hook. This is called at the very beginning of block execution. Read more
source§

fn on_finalize(block_number: BlockNumberFor<T>)

Block finalization hook. This is called at the very end of block execution. Read more
§

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before\n[Hooks::on_finalize]). Read more
§

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by FRAME. Read more
§

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are\ndispatched as separate threads, and entirely independent of the main wasm runtime. Read more
§

fn integrity_test()

Check the integrity of this pallet’s configuration. Read more
","Hooks<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> ProvideInherent for Pallet<T>

§

type Call = Call<T>

The call type of the pallet.
§

type Error = InherentError

The error returned by check_inherent.
source§

const INHERENT_IDENTIFIER: InherentIdentifier = INHERENT_IDENTIFIER

The inherent identifier used by this inherent.
source§

fn create_inherent(data: &InherentData) -> Option<Self::Call>

Create an inherent out of the given InherentData. Read more
source§

fn is_inherent_required(\n data: &InherentData\n) -> Result<Option<Self::Error>, Self::Error>

Determines whether this inherent is required in this block. Read more
source§

fn check_inherent(\n call: &Self::Call,\n data: &InherentData\n) -> Result<(), Self::Error>

Check whether the given inherent is valid. Checking the inherent is optional and can be\nomitted by using the default implementation. Read more
source§

fn is_inherent(call: &Self::Call) -> bool

Return whether the call is an inherent call. Read more
","ProvideInherent","pallet_subspace::pallet::Module"],["
source§

impl<T> Eq for Pallet<T>

","Eq","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> StorageInfoTrait for Pallet<T>

source§

fn storage_info() -> Vec<StorageInfo>

","StorageInfoTrait","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> FindVotingRewardAddresses<<T as Config>::AccountId> for Pallet<T>

source§

fn find_voting_reward_addresses() -> Vec<T::AccountId>

Find the addresses for voting rewards based on transactions found in the block.
","FindVotingRewardAddresses<::AccountId>","pallet_subspace::pallet::Module"],["
source§

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Self

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
","Clone","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> FindBlockRewardAddress<<T as Config>::AccountId> for Pallet<T>

source§

fn find_block_reward_address() -> Option<T::AccountId>

Find the address for a block rewards based on the pre-runtime digests.
","FindBlockRewardAddress<::AccountId>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnGenesis for Pallet<T>

source§

fn on_genesis()

Something that should happen at genesis.
","OnGenesis","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> WhitelistedStorageKeys for Pallet<T>

source§

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

Returns a Vec<TrackedStorageKey> indicating the storage keys that\nshould be whitelisted during benchmarking. This means that those keys\nwill be excluded from the benchmarking performance calculation.
","WhitelistedStorageKeys","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnRuntimeUpgrade for Pallet<T>

source§

fn on_runtime_upgrade() -> Weight

See [Hooks::on_runtime_upgrade].
","OnRuntimeUpgrade","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> PalletsInfoAccess for Pallet<T>

source§

fn count() -> usize

The number of pallets’ information that this type represents. Read more
source§

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.
","PalletsInfoAccess","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnOffenceHandler<Public> for Pallet<T>

source§

fn on_offence(offenders: &[OffenceDetails<FarmerPublicKey>])

A handler for an offence of a particular kind. Read more
","OnOffenceHandler","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> IntegrityTest for Pallet<T>

source§

fn integrity_test()

See [Hooks::integrity_test].
","IntegrityTest","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_initialize(n: BlockNumberFor<T>) -> Weight

See [Hooks::on_initialize].
","OnInitialize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn offchain_worker(n: BlockNumberFor<T>)

This function is being called after every block import (when fully synced). Read more
","OffchainWorker<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> GetStorageVersion for Pallet<T>

§

type CurrentStorageVersion = NoStorageVersionSet

This will be filled out by the pallet macro. Read more
source§

fn current_storage_version() -> Self::CurrentStorageVersion

Returns the current storage version as supported by the pallet.
source§

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.
","GetStorageVersion","pallet_subspace::pallet::Module"],["
source§

impl<T: Config> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>

source§

fn on_finalize(n: BlockNumberFor<T>)

See [Hooks::on_finalize].
","OnFinalize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","pallet_subspace::pallet::Module"]], "subspace_runtime":[["
source§

impl<T> Pallet<T>
where\n T: Config,

Methods for the ValidateUnsigned implementation:\nIt restricts calls to report_equivocation to local calls (i.e. extrinsics generated on this\nnode) or that already in a block. This guarantees that only block authors can include\nequivocation reports.

\n
source

pub fn validate_equivocation_report(\n source: TransactionSource,\n equivocation_proof: &EquivocationProof<<<T as Config>::Block as HeaderProvider>::HeaderT, Public>\n) -> Result<ValidTransaction, TransactionValidityError>

source

pub fn pre_dispatch_equivocation_report(\n equivocation_proof: &EquivocationProof<<<T as Config>::Block as HeaderProvider>::HeaderT, Public>\n) -> Result<(), TransactionValidityError>

",0,"subspace_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn report_equivocation(\n origin: <T as Config>::RuntimeOrigin,\n equivocation_proof: Box<EquivocationProof<<<T as Config>::Block as HeaderProvider>::HeaderT, Public>>\n) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

Report farmer equivocation/misbehavior. This method will verify the equivocation proof.\nIf valid, the offence will be reported.

\n

This extrinsic must be called unsigned and it is expected that only block authors will\ncall it (validated in ValidateUnsigned), as such if the block author is defined it\nwill be defined as the equivocation reporter.

\n
source

pub fn store_segment_headers(\n origin: <T as Config>::RuntimeOrigin,\n segment_headers: Vec<SegmentHeader>\n) -> Result<(), DispatchError>

Submit new segment header to the blockchain. This is an inherent extrinsic and part of\nthe Subspace consensus logic.

\n
source

pub fn enable_solution_range_adjustment(\n origin: <T as Config>::RuntimeOrigin,\n solution_range_override: Option<u64>,\n voting_solution_range_override: Option<u64>\n) -> Result<(), DispatchError>

Enable solution range adjustment after every era.\nNote: No effect on the solution range for the current era

\n
source

pub fn vote(\n origin: <T as Config>::RuntimeOrigin,\n signed_vote: Box<SignedVote<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, <T as Config>::Hash, <T as Config>::AccountId>>\n) -> Result<(), DispatchError>

Farmer vote, currently only used for extra rewards to farmers.

\n
source

pub fn enable_rewards_at(\n origin: <T as Config>::RuntimeOrigin,\n enable_rewards_at: EnableRewardsAt<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>\n) -> Result<(), DispatchError>

Enable rewards for blocks and votes at specified block height.

\n
source

pub fn enable_authoring_by_anyone(\n origin: <T as Config>::RuntimeOrigin\n) -> Result<(), DispatchError>

Enable storage access for all users.

\n
",0,"subspace_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn genesis_slot() -> Slot

An auto-generated getter for GenesisSlot.

\n
",0,"subspace_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn current_slot() -> Slot

An auto-generated getter for CurrentSlot.

\n
",0,"subspace_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn solution_ranges() -> SolutionRanges

An auto-generated getter for SolutionRanges.

\n
",0,"subspace_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn should_adjust_solution_range() -> bool

An auto-generated getter for ShouldAdjustSolutionRange.

\n
",0,"subspace_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn segment_commitment<KArg>(k: KArg) -> Option<SegmentCommitment>
where\n KArg: EncodeLike<SegmentIndex>,

An auto-generated getter for SegmentCommitment.

\n
",0,"subspace_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn root_plot_public_key() -> Option<Public>

An auto-generated getter for RootPlotPublicKey.

\n
",0,"subspace_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn history_size() -> HistorySize

Total number of pieces in the blockchain

\n
source

pub fn submit_equivocation_report(\n equivocation_proof: EquivocationProof<<<T as Config>::Block as HeaderProvider>::HeaderT, Public>\n) -> Option<()>

Submits an extrinsic to report an equivocation. This method will create an unsigned\nextrinsic with a call to report_equivocation and will push the transaction to the pool.\nOnly useful in an offchain context.

\n
source

pub fn submit_test_equivocation_report(\n equivocation_proof: EquivocationProof<<<T as Config>::Block as HeaderProvider>::HeaderT, Public>\n) -> Option<()>

Just stores offender from equivocation report in block list, only used for tests.

\n
source

pub fn pot_parameters() -> PotParameters

Proof of time parameters

\n
source

pub fn is_in_block_list(farmer_public_key: &Public) -> bool

Check if farmer_public_key is in block list (due to equivocation)

\n
source

pub fn archived_history_size() -> u64

Size of the archived history of the blockchain in bytes

\n
",0,"subspace_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config + SendTransactionTypes<Call<T>>,

source

pub fn submit_vote(\n signed_vote: SignedVote<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, <T as Config>::Hash, <T as Config>::AccountId>\n)

Submit farmer vote vote that is essentially a header with bigger solution range than\nacceptable for block authoring.

\n
",0,"subspace_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

This impl block contains no items.

Methods for the ValidateUnsigned implementation:\nIt restricts calls to store_segment_header to local calls (i.e. extrinsics generated on this\nnode) or that already in a block. This guarantees that only block authors can include root\nblocks.

\n
",0,"subspace_runtime::Subspace"],["
source§

impl<T> OnRuntimeUpgrade for Pallet<T>
where\n T: Config,

source§

fn on_runtime_upgrade() -> Weight

See [Hooks::on_runtime_upgrade].
","OnRuntimeUpgrade","subspace_runtime::Subspace"],["
source§

impl<T> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn on_idle(\n n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number,\n remaining_weight: Weight\n) -> Weight

See [Hooks::on_idle].
","OnIdle<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_runtime::Subspace"],["
source§

impl<T> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn on_finalize(\n n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number\n)

See [Hooks::on_finalize].
","OnFinalize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_runtime::Subspace"],["
source§

impl<T> StorageInfoTrait for Pallet<T>
where\n T: Config,

source§

fn storage_info() -> Vec<StorageInfo>

","StorageInfoTrait","subspace_runtime::Subspace"],["
source§

impl<T> Callable<T> for Pallet<T>
where\n T: Config,

§

type RuntimeCall = Call<T>

","Callable","subspace_runtime::Subspace"],["
source§

impl<T> PartialEq for Pallet<T>

source§

fn eq(&self, other: &Pallet<T>) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","subspace_runtime::Subspace"],["
source§

impl<T> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn on_initialize(\n n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number\n) -> Weight

See [Hooks::on_initialize].
","OnInitialize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_runtime::Subspace"],["
source§

impl<T> GetStorageVersion for Pallet<T>
where\n T: Config,

§

type CurrentStorageVersion = NoStorageVersionSet

This will be filled out by the pallet macro. Read more
source§

fn current_storage_version(\n) -> <Pallet<T> as GetStorageVersion>::CurrentStorageVersion

Returns the current storage version as supported by the pallet.
source§

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.
","GetStorageVersion","subspace_runtime::Subspace"],["
source§

impl<T> ValidateUnsigned for Pallet<T>
where\n T: Config,

§

type Call = Call<T>

The call to validate
source§

fn validate_unsigned(\n source: TransactionSource,\n call: &<Pallet<T> as ValidateUnsigned>::Call\n) -> Result<ValidTransaction, TransactionValidityError>

Return the validity of the call Read more
source§

fn pre_dispatch(\n call: &<Pallet<T> as ValidateUnsigned>::Call\n) -> Result<(), TransactionValidityError>

Validate the call right before dispatch. Read more
","ValidateUnsigned","subspace_runtime::Subspace"],["
source§

impl<T> Debug for Pallet<T>

source§

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

Formats the value using the given formatter. Read more
","Debug","subspace_runtime::Subspace"],["
source§

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Pallet<T>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
","Clone","subspace_runtime::Subspace"],["
source§

impl<T> WhitelistedStorageKeys for Pallet<T>
where\n T: Config,

source§

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

Returns a Vec<TrackedStorageKey> indicating the storage keys that\nshould be whitelisted during benchmarking. This means that those keys\nwill be excluded from the benchmarking performance calculation.
","WhitelistedStorageKeys","subspace_runtime::Subspace"],["
source§

impl<T> Eq for Pallet<T>

","Eq","subspace_runtime::Subspace"],["
source§

impl<T> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn offchain_worker(\n n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number\n)

This function is being called after every block import (when fully synced). Read more
","OffchainWorker<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_runtime::Subspace"],["
source§

impl<T> IntegrityTest for Pallet<T>
where\n T: Config,

source§

fn integrity_test()

See [Hooks::integrity_test].
","IntegrityTest","subspace_runtime::Subspace"],["
source§

impl<T> PalletInfoAccess for Pallet<T>
where\n T: Config,

source§

fn index() -> usize

Index of the pallet as configured in the runtime.
source§

fn name() -> &'static str

Name of the pallet as configured in the runtime.
source§

fn name_hash() -> [u8; 16]

Two128 hash of name.
source§

fn module_name() -> &'static str

Name of the Rust module containing the pallet.
source§

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.
","PalletInfoAccess","subspace_runtime::Subspace"],["
source§

impl<T> OnOffenceHandler<Public> for Pallet<T>
where\n T: Config,

source§

fn on_offence(offenders: &[OffenceDetails<Public>])

A handler for an offence of a particular kind. Read more
","OnOffenceHandler","subspace_runtime::Subspace"],["
source§

impl<T> OnGenesis for Pallet<T>
where\n T: Config,

source§

fn on_genesis()

Something that should happen at genesis.
","OnGenesis","subspace_runtime::Subspace"],["
source§

impl<T> BeforeAllRuntimeMigrations for Pallet<T>
where\n T: Config,

source§

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.
","BeforeAllRuntimeMigrations","subspace_runtime::Subspace"],["
source§

impl<T> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn on_initialize(\n block_number: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number\n) -> Weight

Block initialization hook. This is called at the very beginning of block execution. Read more
source§

fn on_finalize(\n block_number: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number\n)

Block finalization hook. This is called at the very end of block execution. Read more
§

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before\n[Hooks::on_finalize]). Read more
§

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by FRAME. Read more
§

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are\ndispatched as separate threads, and entirely independent of the main wasm runtime. Read more
§

fn integrity_test()

Check the integrity of this pallet’s configuration. Read more
","Hooks<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_runtime::Subspace"],["
source§

impl<T> FindVotingRewardAddresses<<T as Config>::AccountId> for Pallet<T>
where\n T: Config,

source§

fn find_voting_reward_addresses() -> Vec<<T as Config>::AccountId>

Find the addresses for voting rewards based on transactions found in the block.
","FindVotingRewardAddresses<::AccountId>","subspace_runtime::Subspace"],["
source§

impl<T> PalletsInfoAccess for Pallet<T>
where\n T: Config,

source§

fn count() -> usize

The number of pallets’ information that this type represents. Read more
source§

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.
","PalletsInfoAccess","subspace_runtime::Subspace"],["
source§

impl<T> ProvideInherent for Pallet<T>
where\n T: Config,

§

type Call = Call<T>

The call type of the pallet.
§

type Error = InherentError

The error returned by check_inherent.
source§

const INHERENT_IDENTIFIER: [u8; 8] = INHERENT_IDENTIFIER

The inherent identifier used by this inherent.
source§

fn create_inherent(\n data: &InherentData\n) -> Option<<Pallet<T> as ProvideInherent>::Call>

Create an inherent out of the given InherentData. Read more
source§

fn is_inherent_required(\n data: &InherentData\n) -> Result<Option<<Pallet<T> as ProvideInherent>::Error>, <Pallet<T> as ProvideInherent>::Error>

Determines whether this inherent is required in this block. Read more
source§

fn check_inherent(\n call: &<Pallet<T> as ProvideInherent>::Call,\n data: &InherentData\n) -> Result<(), <Pallet<T> as ProvideInherent>::Error>

Check whether the given inherent is valid. Checking the inherent is optional and can be\nomitted by using the default implementation. Read more
source§

fn is_inherent(call: &<Pallet<T> as ProvideInherent>::Call) -> bool

Return whether the call is an inherent call. Read more
","ProvideInherent","subspace_runtime::Subspace"],["
source§

impl<T> FindBlockRewardAddress<<T as Config>::AccountId> for Pallet<T>
where\n T: Config,

source§

fn find_block_reward_address() -> Option<<T as Config>::AccountId>

Find the address for a block rewards based on the pre-runtime digests.
","FindBlockRewardAddress<::AccountId>","subspace_runtime::Subspace"],["
source§

impl<T> Randomness<<T as Config>::Hash, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn random(\n subject: &[u8]\n) -> (<T as Config>::Hash, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number)

Get the most recently determined random seed, along with the time in the past\nsince when it was determinable by chain observers. Read more
source§

fn random_seed(\n) -> (<T as Config>::Hash, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number)

Get the basic random seed. Read more
","Randomness<::Hash, <<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_runtime::Subspace"]], "subspace_test_runtime":[["
source§

impl<T> Pallet<T>
where\n T: Config,

Methods for the ValidateUnsigned implementation:\nIt restricts calls to report_equivocation to local calls (i.e. extrinsics generated on this\nnode) or that already in a block. This guarantees that only block authors can include\nequivocation reports.

\n
source

pub fn validate_equivocation_report(\n source: TransactionSource,\n equivocation_proof: &EquivocationProof<<<T as Config>::Block as HeaderProvider>::HeaderT, Public>\n) -> Result<ValidTransaction, TransactionValidityError>

source

pub fn pre_dispatch_equivocation_report(\n equivocation_proof: &EquivocationProof<<<T as Config>::Block as HeaderProvider>::HeaderT, Public>\n) -> Result<(), TransactionValidityError>

",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn report_equivocation(\n origin: <T as Config>::RuntimeOrigin,\n equivocation_proof: Box<EquivocationProof<<<T as Config>::Block as HeaderProvider>::HeaderT, Public>>\n) -> Result<PostDispatchInfo, DispatchErrorWithPostInfo<PostDispatchInfo>>

Report farmer equivocation/misbehavior. This method will verify the equivocation proof.\nIf valid, the offence will be reported.

\n

This extrinsic must be called unsigned and it is expected that only block authors will\ncall it (validated in ValidateUnsigned), as such if the block author is defined it\nwill be defined as the equivocation reporter.

\n
source

pub fn store_segment_headers(\n origin: <T as Config>::RuntimeOrigin,\n segment_headers: Vec<SegmentHeader>\n) -> Result<(), DispatchError>

Submit new segment header to the blockchain. This is an inherent extrinsic and part of\nthe Subspace consensus logic.

\n
source

pub fn enable_solution_range_adjustment(\n origin: <T as Config>::RuntimeOrigin,\n solution_range_override: Option<u64>,\n voting_solution_range_override: Option<u64>\n) -> Result<(), DispatchError>

Enable solution range adjustment after every era.\nNote: No effect on the solution range for the current era

\n
source

pub fn vote(\n origin: <T as Config>::RuntimeOrigin,\n signed_vote: Box<SignedVote<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, <T as Config>::Hash, <T as Config>::AccountId>>\n) -> Result<(), DispatchError>

Farmer vote, currently only used for extra rewards to farmers.

\n
source

pub fn enable_rewards_at(\n origin: <T as Config>::RuntimeOrigin,\n enable_rewards_at: EnableRewardsAt<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number>\n) -> Result<(), DispatchError>

Enable rewards for blocks and votes at specified block height.

\n
source

pub fn enable_authoring_by_anyone(\n origin: <T as Config>::RuntimeOrigin\n) -> Result<(), DispatchError>

Enable storage access for all users.

\n
",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn genesis_slot() -> Slot

An auto-generated getter for GenesisSlot.

\n
",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn current_slot() -> Slot

An auto-generated getter for CurrentSlot.

\n
",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn solution_ranges() -> SolutionRanges

An auto-generated getter for SolutionRanges.

\n
",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn should_adjust_solution_range() -> bool

An auto-generated getter for ShouldAdjustSolutionRange.

\n
",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn segment_commitment<KArg>(k: KArg) -> Option<SegmentCommitment>
where\n KArg: EncodeLike<SegmentIndex>,

An auto-generated getter for SegmentCommitment.

\n
",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn root_plot_public_key() -> Option<Public>

An auto-generated getter for RootPlotPublicKey.

\n
",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

source

pub fn history_size() -> HistorySize

Total number of pieces in the blockchain

\n
source

pub fn submit_equivocation_report(\n equivocation_proof: EquivocationProof<<<T as Config>::Block as HeaderProvider>::HeaderT, Public>\n) -> Option<()>

Submits an extrinsic to report an equivocation. This method will create an unsigned\nextrinsic with a call to report_equivocation and will push the transaction to the pool.\nOnly useful in an offchain context.

\n
source

pub fn submit_test_equivocation_report(\n equivocation_proof: EquivocationProof<<<T as Config>::Block as HeaderProvider>::HeaderT, Public>\n) -> Option<()>

Just stores offender from equivocation report in block list, only used for tests.

\n
source

pub fn pot_parameters() -> PotParameters

Proof of time parameters

\n
source

pub fn is_in_block_list(farmer_public_key: &Public) -> bool

Check if farmer_public_key is in block list (due to equivocation)

\n
source

pub fn archived_history_size() -> u64

Size of the archived history of the blockchain in bytes

\n
",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config + SendTransactionTypes<Call<T>>,

source

pub fn submit_vote(\n signed_vote: SignedVote<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number, <T as Config>::Hash, <T as Config>::AccountId>\n)

Submit farmer vote vote that is essentially a header with bigger solution range than\nacceptable for block authoring.

\n
",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> Pallet<T>
where\n T: Config,

This impl block contains no items.

Methods for the ValidateUnsigned implementation:\nIt restricts calls to store_segment_header to local calls (i.e. extrinsics generated on this\nnode) or that already in a block. This guarantees that only block authors can include root\nblocks.

\n
",0,"subspace_test_runtime::Subspace"],["
source§

impl<T> OnRuntimeUpgrade for Pallet<T>
where\n T: Config,

source§

fn on_runtime_upgrade() -> Weight

See [Hooks::on_runtime_upgrade].
","OnRuntimeUpgrade","subspace_test_runtime::Subspace"],["
source§

impl<T> OnIdle<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn on_idle(\n n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number,\n remaining_weight: Weight\n) -> Weight

See [Hooks::on_idle].
","OnIdle<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_test_runtime::Subspace"],["
source§

impl<T> OnFinalize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn on_finalize(\n n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number\n)

See [Hooks::on_finalize].
","OnFinalize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_test_runtime::Subspace"],["
source§

impl<T> StorageInfoTrait for Pallet<T>
where\n T: Config,

source§

fn storage_info() -> Vec<StorageInfo>

","StorageInfoTrait","subspace_test_runtime::Subspace"],["
source§

impl<T> Callable<T> for Pallet<T>
where\n T: Config,

§

type RuntimeCall = Call<T>

","Callable","subspace_test_runtime::Subspace"],["
source§

impl<T> PartialEq for Pallet<T>

source§

fn eq(&self, other: &Pallet<T>) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
1.0.0 · source§

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","subspace_test_runtime::Subspace"],["
source§

impl<T> OnInitialize<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn on_initialize(\n n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number\n) -> Weight

See [Hooks::on_initialize].
","OnInitialize<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_test_runtime::Subspace"],["
source§

impl<T> GetStorageVersion for Pallet<T>
where\n T: Config,

§

type CurrentStorageVersion = NoStorageVersionSet

This will be filled out by the pallet macro. Read more
source§

fn current_storage_version(\n) -> <Pallet<T> as GetStorageVersion>::CurrentStorageVersion

Returns the current storage version as supported by the pallet.
source§

fn on_chain_storage_version() -> StorageVersion

Returns the on-chain storage version of the pallet as stored in the storage.
","GetStorageVersion","subspace_test_runtime::Subspace"],["
source§

impl<T> ValidateUnsigned for Pallet<T>
where\n T: Config,

§

type Call = Call<T>

The call to validate
source§

fn validate_unsigned(\n source: TransactionSource,\n call: &<Pallet<T> as ValidateUnsigned>::Call\n) -> Result<ValidTransaction, TransactionValidityError>

Return the validity of the call Read more
source§

fn pre_dispatch(\n call: &<Pallet<T> as ValidateUnsigned>::Call\n) -> Result<(), TransactionValidityError>

Validate the call right before dispatch. Read more
","ValidateUnsigned","subspace_test_runtime::Subspace"],["
source§

impl<T> Debug for Pallet<T>

source§

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

Formats the value using the given formatter. Read more
","Debug","subspace_test_runtime::Subspace"],["
source§

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Pallet<T>

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
","Clone","subspace_test_runtime::Subspace"],["
source§

impl<T> WhitelistedStorageKeys for Pallet<T>
where\n T: Config,

source§

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

Returns a Vec<TrackedStorageKey> indicating the storage keys that\nshould be whitelisted during benchmarking. This means that those keys\nwill be excluded from the benchmarking performance calculation.
","WhitelistedStorageKeys","subspace_test_runtime::Subspace"],["
source§

impl<T> Eq for Pallet<T>

","Eq","subspace_test_runtime::Subspace"],["
source§

impl<T> OffchainWorker<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn offchain_worker(\n n: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number\n)

This function is being called after every block import (when fully synced). Read more
","OffchainWorker<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_test_runtime::Subspace"],["
source§

impl<T> IntegrityTest for Pallet<T>
where\n T: Config,

source§

fn integrity_test()

See [Hooks::integrity_test].
","IntegrityTest","subspace_test_runtime::Subspace"],["
source§

impl<T> PalletInfoAccess for Pallet<T>
where\n T: Config,

source§

fn index() -> usize

Index of the pallet as configured in the runtime.
source§

fn name() -> &'static str

Name of the pallet as configured in the runtime.
source§

fn name_hash() -> [u8; 16]

Two128 hash of name.
source§

fn module_name() -> &'static str

Name of the Rust module containing the pallet.
source§

fn crate_version() -> CrateVersion

Version of the crate containing the pallet.
","PalletInfoAccess","subspace_test_runtime::Subspace"],["
source§

impl<T> OnOffenceHandler<Public> for Pallet<T>
where\n T: Config,

source§

fn on_offence(offenders: &[OffenceDetails<Public>])

A handler for an offence of a particular kind. Read more
","OnOffenceHandler","subspace_test_runtime::Subspace"],["
source§

impl<T> OnGenesis for Pallet<T>
where\n T: Config,

source§

fn on_genesis()

Something that should happen at genesis.
","OnGenesis","subspace_test_runtime::Subspace"],["
source§

impl<T> BeforeAllRuntimeMigrations for Pallet<T>
where\n T: Config,

source§

fn before_all_runtime_migrations() -> Weight

Something that should happen before runtime migrations are executed.
","BeforeAllRuntimeMigrations","subspace_test_runtime::Subspace"],["
source§

impl<T> Hooks<<<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn on_initialize(\n block_number: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number\n) -> Weight

Block initialization hook. This is called at the very beginning of block execution. Read more
source§

fn on_finalize(\n block_number: <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number\n)

Block finalization hook. This is called at the very end of block execution. Read more
§

fn on_idle(_n: BlockNumber, _remaining_weight: Weight) -> Weight

Hook to consume a block’s idle time. This will run when the block is being finalized (before\n[Hooks::on_finalize]). Read more
§

fn on_runtime_upgrade() -> Weight

Hook executed when a code change (aka. a “runtime upgrade”) is detected by FRAME. Read more
§

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are\ndispatched as separate threads, and entirely independent of the main wasm runtime. Read more
§

fn integrity_test()

Check the integrity of this pallet’s configuration. Read more
","Hooks<<<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_test_runtime::Subspace"],["
source§

impl<T> FindVotingRewardAddresses<<T as Config>::AccountId> for Pallet<T>
where\n T: Config,

source§

fn find_voting_reward_addresses() -> Vec<<T as Config>::AccountId>

Find the addresses for voting rewards based on transactions found in the block.
","FindVotingRewardAddresses<::AccountId>","subspace_test_runtime::Subspace"],["
source§

impl<T> PalletsInfoAccess for Pallet<T>
where\n T: Config,

source§

fn count() -> usize

The number of pallets’ information that this type represents. Read more
source§

fn infos() -> Vec<PalletInfoData>

All of the pallets’ information that this type represents.
","PalletsInfoAccess","subspace_test_runtime::Subspace"],["
source§

impl<T> ProvideInherent for Pallet<T>
where\n T: Config,

§

type Call = Call<T>

The call type of the pallet.
§

type Error = InherentError

The error returned by check_inherent.
source§

const INHERENT_IDENTIFIER: [u8; 8] = INHERENT_IDENTIFIER

The inherent identifier used by this inherent.
source§

fn create_inherent(\n data: &InherentData\n) -> Option<<Pallet<T> as ProvideInherent>::Call>

Create an inherent out of the given InherentData. Read more
source§

fn is_inherent_required(\n data: &InherentData\n) -> Result<Option<<Pallet<T> as ProvideInherent>::Error>, <Pallet<T> as ProvideInherent>::Error>

Determines whether this inherent is required in this block. Read more
source§

fn check_inherent(\n call: &<Pallet<T> as ProvideInherent>::Call,\n data: &InherentData\n) -> Result<(), <Pallet<T> as ProvideInherent>::Error>

Check whether the given inherent is valid. Checking the inherent is optional and can be\nomitted by using the default implementation. Read more
source§

fn is_inherent(call: &<Pallet<T> as ProvideInherent>::Call) -> bool

Return whether the call is an inherent call. Read more
","ProvideInherent","subspace_test_runtime::Subspace"],["
source§

impl<T> FindBlockRewardAddress<<T as Config>::AccountId> for Pallet<T>
where\n T: Config,

source§

fn find_block_reward_address() -> Option<<T as Config>::AccountId>

Find the address for a block rewards based on the pre-runtime digests.
","FindBlockRewardAddress<::AccountId>","subspace_test_runtime::Subspace"],["
source§

impl<T> Randomness<<T as Config>::Hash, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number> for Pallet<T>
where\n T: Config,

source§

fn random(\n subject: &[u8]\n) -> (<T as Config>::Hash, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number)

Get the most recently determined random seed, along with the time in the past\nsince when it was determinable by chain observers. Read more
source§

fn random_seed(\n) -> (<T as Config>::Hash, <<<T as Config>::Block as HeaderProvider>::HeaderT as Header>::Number)

Get the basic random seed. Read more
","Randomness<::Hash, <<::Block as HeaderProvider>::HeaderT as Header>::Number>","subspace_test_runtime::Subspace"]] };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})() \ No newline at end of file diff --git a/type.impl/std/primitive.array.js b/type.impl/std/primitive.array.js index a87dd67712..fbc7a1d0ae 100644 --- a/type.impl/std/primitive.array.js +++ b/type.impl/std/primitive.array.js @@ -1,4 +1,4 @@ (function() {var type_impls = { -"sp_consensus_subspace":[["
1.4.0 · source§

impl<T, const N: usize> Borrow<[T]> for [T; N]

source§

fn borrow(&self) -> &[T]

Immutably borrows from an owned value. Read more
","Borrow<[T]>","sp_consensus_subspace::offence::Kind"],["
1.50.0 · source§

impl<T, I, const N: usize> IndexMut<I> for [T; N]
where\n [T]: IndexMut<I>,

source§

fn index_mut(&mut self, index: I) -> &mut <[T; N] as Index<I>>::Output

Performs the mutable indexing (container[index]) operation. Read more
","IndexMut","sp_consensus_subspace::offence::Kind"],["
source§

impl<T, const N: usize> StructuralEq for [T; N]

","StructuralEq","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> Eq for [T; N]
where\n T: Eq,

","Eq","sp_consensus_subspace::offence::Kind"],["
1.53.0 · source§

impl<T, const N: usize> IntoIterator for [T; N]

source§

fn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter

Creates a consuming iterator, that is, one that moves each value out of\nthe array (from start to end). The array cannot be used after calling\nthis unless T implements Copy, so the whole array is copied.

\n

Arrays have special behavior when calling .into_iter() prior to the\n2021 edition – see the array Editions section for more information.

\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T, N>

Which kind of iterator are we turning this into?
","IntoIterator","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> Ord for [T; N]
where\n T: Ord,

Implements comparison of arrays lexicographically.

\n
source§

fn cmp(&self, other: &[T; N]) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","sp_consensus_subspace::offence::Kind"],["
1.58.0 · source§

impl<T, const N: usize> Copy for [T; N]
where\n T: Copy,

","Copy","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> AsRef<[T]> for [T; N]

source§

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.
","AsRef<[T]>","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &[B; N]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &[B; N]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<[B; N]>","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<&[B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &&[B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &&[B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<&[B]>","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<&mut [B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &&mut [B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &&mut [B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<&mut [B]>","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<[B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &[B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &[B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<[B]>","sp_consensus_subspace::offence::Kind"],["
source§

impl<T, const N: usize> ConstParamTy for [T; N]
where\n T: ConstParamTy,

","ConstParamTy","sp_consensus_subspace::offence::Kind"],["
source§

impl<T, const N: usize> From<Simd<T, N>> for [T; N]
where\n LaneCount<N>: SupportedLaneCount,\n T: SimdElement,

source§

fn from(vector: Simd<T, N>) -> [T; N]

Converts to this type from the input type.
","From>","sp_consensus_subspace::offence::Kind"],["
source§

impl<T, const N: usize> StructuralPartialEq for [T; N]

","StructuralPartialEq","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 22]
where\n T: Default,

source§

fn default() -> [T; 22]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 21]
where\n T: Default,

source§

fn default() -> [T; 21]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 31]
where\n T: Default,

source§

fn default() -> [T; 31]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 4]
where\n T: Default,

source§

fn default() -> [T; 4]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 9]
where\n T: Default,

source§

fn default() -> [T; 9]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 2]
where\n T: Default,

source§

fn default() -> [T; 2]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 5]
where\n T: Default,

source§

fn default() -> [T; 5]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 7]
where\n T: Default,

source§

fn default() -> [T; 7]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 11]
where\n T: Default,

source§

fn default() -> [T; 11]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 15]
where\n T: Default,

source§

fn default() -> [T; 15]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 27]
where\n T: Default,

source§

fn default() -> [T; 27]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 1]
where\n T: Default,

source§

fn default() -> [T; 1]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 17]
where\n T: Default,

source§

fn default() -> [T; 17]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 20]
where\n T: Default,

source§

fn default() -> [T; 20]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 19]
where\n T: Default,

source§

fn default() -> [T; 19]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 26]
where\n T: Default,

source§

fn default() -> [T; 26]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 25]
where\n T: Default,

source§

fn default() -> [T; 25]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 24]
where\n T: Default,

source§

fn default() -> [T; 24]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 10]
where\n T: Default,

source§

fn default() -> [T; 10]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 0]

source§

fn default() -> [T; 0]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 14]
where\n T: Default,

source§

fn default() -> [T; 14]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 30]
where\n T: Default,

source§

fn default() -> [T; 30]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 12]
where\n T: Default,

source§

fn default() -> [T; 12]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 8]
where\n T: Default,

source§

fn default() -> [T; 8]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 13]
where\n T: Default,

source§

fn default() -> [T; 13]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 18]
where\n T: Default,

source§

fn default() -> [T; 18]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 16]
where\n T: Default,

source§

fn default() -> [T; 16]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 6]
where\n T: Default,

source§

fn default() -> [T; 6]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 28]
where\n T: Default,

source§

fn default() -> [T; 28]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 3]
where\n T: Default,

source§

fn default() -> [T; 3]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 29]
where\n T: Default,

source§

fn default() -> [T; 29]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 23]
where\n T: Default,

source§

fn default() -> [T; 23]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.34.0 · source§

impl<T, const N: usize> TryFrom<&[T]> for [T; N]
where\n T: Copy,

Tries to create an array [T; N] by copying from a slice &[T]. Succeeds if\nslice.len() == N.

\n\n
let bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = bytes[1..3].try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));
\n
§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &[T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.
","TryFrom<&[T]>","sp_consensus_subspace::offence::Kind"],["
1.59.0 · source§

impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]
where\n T: Copy,

Tries to create an array [T; N] by copying from a mutable slice &mut [T].\nSucceeds if slice.len() == N.

\n\n
let mut bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&mut bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));
\n
§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &mut [T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.
","TryFrom<&mut [T]>","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> PartialOrd for [T; N]
where\n T: PartialOrd,

source§

fn partial_cmp(&self, other: &[T; N]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
source§

fn lt(&self, other: &[T; N]) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
source§

fn le(&self, other: &[T; N]) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
source§

fn ge(&self, other: &[T; N]) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
source§

fn gt(&self, other: &[T; N]) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
","PartialOrd","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> Hash for [T; N]
where\n T: Hash,

The hash of an array is the same as that of the corresponding slice,\nas required by the Borrow implementation.

\n\n
use std::hash::BuildHasher;\n\nlet b = std::hash::RandomState::new();\nlet a: [u8; 3] = [0xa8, 0x3c, 0x09];\nlet s: &[u8] = &[0xa8, 0x3c, 0x09];\nassert_eq!(b.hash_one(a), b.hash_one(s));
\n
source§

fn hash<H>(&self, state: &mut H)
where\n H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T, const N: usize> BorrowMut<[T]> for [T; N]

source§

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value. Read more
","BorrowMut<[T]>","sp_consensus_subspace::offence::Kind"],["
1.58.0 · source§

impl<T, const N: usize> Clone for [T; N]
where\n T: Clone,

source§

fn clone(&self) -> [T; N]

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, other: &[T; N])

Performs copy-assignment from source. Read more
","Clone","sp_consensus_subspace::offence::Kind"],["
1.50.0 · source§

impl<T, I, const N: usize> Index<I> for [T; N]
where\n [T]: Index<I>,

§

type Output = <[T] as Index<I>>::Output

The returned type after indexing.
source§

fn index(&self, index: I) -> &<[T; N] as Index<I>>::Output

Performs the indexing (container[index]) operation. Read more
","Index","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> Debug for [T; N]
where\n T: Debug,

source§

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

Formats the value using the given formatter. Read more
","Debug","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> AsMut<[T]> for [T; N]

source§

fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.
","AsMut<[T]>","sp_consensus_subspace::offence::Kind"],["
1.51.0 · source§

impl<T, const N: usize> SlicePattern for [T; N]

§

type Item = T

🔬This is a nightly-only experimental API. (slice_pattern)
The element type of the slice being matched on.
source§

fn as_slice(&self) -> &[<[T; N] as SlicePattern>::Item]

🔬This is a nightly-only experimental API. (slice_pattern)
Currently, the consumers of SlicePattern need a slice.
","SlicePattern","sp_consensus_subspace::offence::Kind"],["
1.48.0 · source§

impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]
where\n A: Allocator,

source§

fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>

Gets the entire contents of the Vec<T> as an array,\nif its size exactly matches that of the requested array.

\n
Examples
\n
assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));\nassert_eq!(<Vec<i32>>::new().try_into(), Ok([]));
\n

If the length doesn’t match, the input comes back in Err:

\n\n
let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();\nassert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
\n

If you’re fine with just getting a prefix of the Vec<T>,\nyou can call .truncate(N) first.

\n\n
let mut v = String::from(\"hello world\").into_bytes();\nv.sort();\nv.truncate(2);\nlet [a, b]: [_; 2] = v.try_into().unwrap();\nassert_eq!(a, b' ');\nassert_eq!(b, b'd');
\n
§

type Error = Vec<T, A>

The type returned in the event of a conversion error.
","TryFrom>","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> Encode for [T; N]
where\n T: Encode,

§

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
§

fn encode_to<W>(&self, dest: &mut W)
where\n W: Output + ?Sized,

Convert self to a slice and append it to the destination.
§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
§

fn using_encoded<R, F>(&self, f: F) -> R
where\n F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
","Encode","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> MaxEncodedLen for [T; N]
where\n T: MaxEncodedLen,

§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
","MaxEncodedLen","sp_consensus_subspace::offence::Kind"],["
§

impl<T, U, const N: usize> EncodeLike<[U; N]> for [T; N]
where\n T: EncodeLike<U>,\n U: Encode,

","EncodeLike<[U; N]>","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> ConstEncodedLen for [T; N]
where\n T: ConstEncodedLen,

","ConstEncodedLen","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> Decode for [T; N]
where\n T: Decode,

§

fn decode<I>(input: &mut I) -> Result<[T; N], Error>
where\n I: Input,

Attempt to deserialise the value from input.
§

fn decode_into<I>(\n input: &mut I,\n dst: &mut MaybeUninit<[T; N]>\n) -> Result<DecodeFinished, Error>
where\n I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory. Read more
§

fn skip<I>(input: &mut I) -> Result<(), Error>
where\n I: Input,

Attempt to skip the encoded value from input. Read more
§

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
","Decode","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> FromByteSlice for [u8; N]

§

fn from_byte_slice<T>(slice: &T) -> Result<&[[u8; N]], Error>
where\n T: AsRef<[u8]> + ?Sized,

Convert from an immutable byte slice to a immutable slice of a fundamental, built-in\nnumeric type
§

fn from_mut_byte_slice<T>(slice: &mut T) -> Result<&mut [[u8; N]], Error>
where\n T: AsMut<[u8]> + ?Sized,

Convert from an mutable byte slice to a mutable slice of a fundamental, built-in numeric\ntype
","FromByteSlice","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> ToMutByteSlice for [u8; N]

§

fn to_mut_byte_slice<T>(slice: &mut T) -> &mut [u8] ⓘ
where\n T: AsMut<[[u8; N]]> + ?Sized,

Convert from a mutable slice of a fundamental, built-in numeric type to a mutable byte\nslice
","ToMutByteSlice","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> ToByteSlice for [u8; N]

§

fn to_byte_slice<T>(slice: &T) -> &[u8] ⓘ
where\n T: AsRef<[[u8; N]]> + ?Sized,

Convert from an immutable slice of a fundamental, built-in numeric type to an immutable\nbyte slice
","ToByteSlice","sp_consensus_subspace::offence::Kind"],["
source§

impl<'de, T> Deserialize<'de> for [T; 16]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 16], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Serialize for [T; 16]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> TypeInfo for [T; N]
where\n T: TypeInfo + 'static,

§

type Identity = [T; N]

The type identifying for which type info is provided. Read more
§

fn type_info() -> Type

Returns the static type identifier for Self.
","TypeInfo","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> Printable for [u8; N]

§

fn print(&self)

Print the object.
","Printable","sp_consensus_subspace::offence::Kind"],["
§

impl AsBytesRef for [u8; 16]

§

fn as_bytes_ref(&self) -> &[u8] ⓘ

Transform self into &[u8].
","AsBytesRef","sp_consensus_subspace::offence::Kind"],["
§

impl<const LEFT_PLUS_RIGHT_LEN: usize> From<Signature<LEFT_PLUS_RIGHT_LEN>> for [u8; LEFT_PLUS_RIGHT_LEN]

§

fn from(signature: Signature<LEFT_PLUS_RIGHT_LEN>) -> [u8; LEFT_PLUS_RIGHT_LEN]

Converts to this type from the input type.
","From>","sp_consensus_subspace::offence::Kind"],["
§

impl From<Signature> for [u8; 65]

§

fn from(v: Signature) -> [u8; 65]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
§

impl FromEntropy for [u8; 16]

§

fn from_entropy(input: &mut impl Input) -> Result<[u8; 16], Error>

Create a random value of Self given a stream of random bytes on input. May only fail if\ninput has an error.
","FromEntropy","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> IntoPreallocatedFFIValue for [u8; N]

§

type SelfInstance = [u8; N]

As Self can be an unsized type, it needs to be represented by a sized type at the host.\nThis SelfInstance is the sized type.
§

fn into_preallocated_ffi_value(\n self_instance: <[u8; N] as IntoPreallocatedFFIValue>::SelfInstance,\n context: &mut dyn FunctionContext,\n allocated: u32\n) -> Result<(), String>

Convert self_instance into the given preallocated ffi value.
","IntoPreallocatedFFIValue","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> RIType for [u8; N]

The type is passed as u32.

\n

The u32 is the pointer to the array.

\n
§

type FFIType = u32

The ffi type that is used to represent Self.
","RIType","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> IntoFFIValue for [u8; N]

§

fn into_ffi_value(\n self,\n context: &mut dyn FunctionContext\n) -> Result<u32, String>

Convert self into a ffi value.
","IntoFFIValue","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> FromFFIValue for [u8; N]

§

type SelfInstance = [u8; N]

As Self can be an unsized type, it needs to be represented by a sized type at the host.\nThis SelfInstance is the sized type.
§

fn from_ffi_value(\n context: &mut dyn FunctionContext,\n arg: u32\n) -> Result<[u8; N], String>

Create SelfInstance from the given
","FromFFIValue","sp_consensus_subspace::offence::Kind"],["
§

impl<T> Array for [T; 16]
where\n T: Default,

§

type Item = T

The type of the items in the thing.
§

const CAPACITY: usize = 16usize

The number of slots in the thing.
§

fn as_slice(&self) -> &[T]

Gives a shared slice over the whole thing. Read more
§

fn as_slice_mut(&mut self) -> &mut [T]

Gives a unique slice over the whole thing. Read more
§

fn default() -> [T; 16]

Create a default-initialized instance of ourself, similar to the\nDefault trait, but implemented for the same range of sizes as\n[Array].
","Array","sp_consensus_subspace::offence::Kind"],["
§

impl<T> ArrayLike for [T; 16]

§

type Item = T

Type of the elements being stored.
","ArrayLike","sp_consensus_subspace::offence::Kind"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>> for [T; 16]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>\n) -> [T; 16]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>>>","sp_consensus_subspace::offence::Kind"],["
§

impl<Z, const N: usize> Zeroize for [Z; N]
where\n Z: Zeroize,

Impl [Zeroize] on arrays of types that impl [Zeroize].

\n
§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","sp_consensus_subspace::offence::Kind"],["
§

impl<Z, const N: usize> ZeroizeOnDrop for [Z; N]
where\n Z: ZeroizeOnDrop,

Impl [ZeroizeOnDrop] on arrays of types that impl [ZeroizeOnDrop].

\n
","ZeroizeOnDrop","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> Replacer for [u8; N]

§

fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>)

Appends possibly empty data to dst to replace the current match. Read more
§

fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>>

Return a fixed unchanging replacement byte string. Read more
§

fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self>

Returns a type that implements Replacer, but that borrows and wraps\nthis Replacer. Read more
","Replacer","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> IntoParallelIterator for [T; N]
where\n T: Send,

§

type Item = T

The type of item that the parallel iterator will produce.
§

type Iter = IntoIter<T, N>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <[T; N] as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> Array for [T; N]

§

type Item = T

The type of the array’s elements.
§

fn size() -> usize

Returns the number of items the array can hold.
","Array","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize, T> FromBytes for [T; N]
where\n T: FromBytes,

§

fn ref_from(bytes: &[u8]) -> Option<&Self>
where\n Self: Sized,

Interprets the given bytes as a &Self without copying. Read more
§

fn ref_from_prefix(bytes: &[u8]) -> Option<&Self>
where\n Self: Sized,

Interprets the prefix of the given bytes as a &Self without copying. Read more
§

fn ref_from_suffix(bytes: &[u8]) -> Option<&Self>
where\n Self: Sized,

Interprets the suffix of the given bytes as a &Self without copying. Read more
§

fn slice_from(bytes: &[u8]) -> Option<&[Self]>
where\n Self: Sized,

Interprets the given bytes as a &[Self] without copying. Read more
§

fn slice_from_prefix(bytes: &[u8], count: usize) -> Option<(&[Self], &[u8])>
where\n Self: Sized,

Interprets the prefix of the given bytes as a &[Self] with length\nequal to count without copying. Read more
§

fn slice_from_suffix(bytes: &[u8], count: usize) -> Option<(&[u8], &[Self])>
where\n Self: Sized,

Interprets the suffix of the given bytes as a &[Self] with length\nequal to count without copying. Read more
§

fn read_from(bytes: &[u8]) -> Option<Self>
where\n Self: Sized,

Reads a copy of Self from bytes. Read more
§

fn read_from_prefix(bytes: &[u8]) -> Option<Self>
where\n Self: Sized,

Reads a copy of Self from the prefix of bytes. Read more
§

fn read_from_suffix(bytes: &[u8]) -> Option<Self>
where\n Self: Sized,

Reads a copy of Self from the suffix of bytes. Read more
","FromBytes","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize, T> Unaligned for [T; N]
where\n T: Unaligned,

","Unaligned","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize, T> FromZeroes for [T; N]
where\n T: FromZeroes,

§

fn zero(&mut self)

Overwrites self with zeroes. Read more
§

fn new_zeroed() -> Self
where\n Self: Sized,

Creates an instance of Self from zeroed bytes. Read more
","FromZeroes","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize, T> AsBytes for [T; N]
where\n T: AsBytes,

§

fn as_bytes(&self) -> &[u8] ⓘ

Gets the bytes of this value. Read more
§

fn write_to(&self, bytes: &mut [u8]) -> Option<()>

Writes a copy of self to bytes. Read more
§

fn write_to_prefix(&self, bytes: &mut [u8]) -> Option<()>

Writes a copy of self to the prefix of bytes. Read more
§

fn write_to_suffix(&self, bytes: &mut [u8]) -> Option<()>

Writes a copy of self to the suffix of bytes. Read more
","AsBytes","sp_consensus_subspace::offence::Kind"],["
§

impl From<U256> for [u8; 32]

§

fn from(number: U256) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
§

impl From<U512> for [u8; 64]

§

fn from(number: U512) -> [u8; 64]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
§

impl From<U128> for [u8; 16]

§

fn from(number: U128) -> [u8; 16]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
§

impl From<H128> for [u8; 16]

§

fn from(s: H128) -> [u8; 16]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 21]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 26]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 9]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 16]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 64]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 11]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 10]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 1024]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 4]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 27]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 7]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 128]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 19]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 23]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 2048]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 512]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 1]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 28]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 31]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 12]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 20]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 0]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 15]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 17]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 29]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 8]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 18]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 3]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 13]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 24]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 14]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 30]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 256]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 25]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 5]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 6]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 2]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 22]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl FromHex for [u8; 16]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 16], <[u8; 16] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","sp_consensus_subspace::offence::Kind"],["
§

impl FromHex for [u8; 16]

§

fn from_byte_iter<I>(iter: I) -> Result<[u8; 16], Error>
where\n I: Iterator<Item = Result<u8, Error>> + ExactSizeIterator + DoubleEndedIterator,

Produces an object from a byte iterator.
§

fn from_hex(s: &str) -> Result<Self, Error>

Produces an object from a hex string.
","FromHex","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> DebugSecret for [T; 16]
where\n T: Debug,

source§

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

Format information about the secret’s type. Read more
","DebugSecret","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> CloneableSecret for [T; 16]
where\n T: Clone + Zeroize,

","CloneableSecret","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> DecodeTarget for [u8; N]

§

fn decode_with(\n &mut self,\n max_len: usize,\n f: impl for<'a> FnOnce(&'a mut [u8]) -> Result<usize, Error>\n) -> Result<usize, Error>

Decodes into this buffer, provides the maximum length for implementations that wish to\npreallocate space, along with a function that will write bytes into the buffer and return\nthe length written to it.
","DecodeTarget","sp_consensus_subspace::offence::Kind"],["
§

impl Hex for [u8; 16]

§

fn hex(self, prefix: &str) -> String

Convert [Self] to hex with the given prefix.
","Hex","sp_consensus_subspace::offence::Kind"],["
§

impl TryFromHex for [u8; 16]

§

fn try_from_hex<H>(hex: H) -> Result<[u8; 16], Error>
where\n H: AsRef<[u8]>,

Try to convert [Self] from hex.
","TryFromHex","sp_consensus_subspace::offence::Kind"],["
§

impl From<&Signature> for [u8; 64]

§

fn from(sig: &Signature) -> [u8; 64]

Converts to this type from the input type.
","From<&Signature>","sp_consensus_subspace::offence::Kind"],["
§

impl From<Signature> for [u8; 64]

§

fn from(sig: Signature) -> [u8; 64]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
§

impl<T> ArrayLike for [T; 16]

§

type Item = T

Type of the elements being stored.
","ArrayLike","sp_consensus_subspace::offence::Kind"],["
source§

impl From<&Scalar> for [u8; 32]

source§

fn from(value: &Scalar) -> [u8; 32]

Converts to this type from the input type.
","From<&Scalar>","sp_consensus_subspace::offence::Kind"],["
source§

impl From<SegmentCommitment> for [u8; 48]

source§

fn from(original: SegmentCommitment) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<Witness> for [u8; 48]

source§

fn from(witness: Witness) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<RecordCommitment> for [u8; 48]

source§

fn from(original: RecordCommitment) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<PublicKey> for [u8; 32]

source§

fn from(original: PublicKey) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<Scalar> for [u8; 32]

source§

fn from(value: Scalar) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<RewardSignature> for [u8; 64]

source§

fn from(original: RewardSignature) -> [u8; 64]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<PosSeed> for [u8; 32]

source§

fn from(value: PosSeed) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<PosProof> for [u8; 160]

source§

fn from(value: PosProof) -> [u8; 160]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<ChunkWitness> for [u8; 48]

source§

fn from(original: ChunkWitness) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<U256> for [u8; 32]

source§

fn from(number: U256) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<RecordWitness> for [u8; 48]

source§

fn from(original: RecordWitness) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<&Witness> for [u8; 48]

source§

fn from(witness: &Witness) -> [u8; 48]

Converts to this type from the input type.
","From<&Witness>","sp_consensus_subspace::offence::Kind"],["
source§

impl From<&Commitment> for [u8; 48]

source§

fn from(commitment: &Commitment) -> [u8; 48]

Converts to this type from the input type.
","From<&Commitment>","sp_consensus_subspace::offence::Kind"],["
source§

impl From<Commitment> for [u8; 48]

source§

fn from(commitment: Commitment) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<Randomness> for [u8; 32]

source§

fn from(original: Randomness) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl<T, const N: usize> [T; N]

1.55.0 · source

pub fn map<F, U>(self, f: F) -> [U; N]
where\n F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element\nin order.

\n

If you don’t necessarily need a new fixed-size array, consider using\nIterator::map instead.

\n
Note on performance and stack usage
\n

Unfortunately, usages of this method are currently not always optimized\nas well as they could be. This mainly concerns large arrays, as mapping\nover small arrays seem to be optimized just fine. Also note that in\ndebug mode (i.e. without any optimizations), this method can use a lot\nof stack space (a few times the size of the array or more).

\n

Therefore, in performance-critical code, try to avoid using this method\non large arrays or check the emitted code. Also try to avoid chained\nmaps (e.g. arr.map(...).map(...)).

\n

In many cases, you can instead use Iterator::map by calling .iter()\nor .into_iter() on your array. [T; N]::map is only necessary if you\nreally need a new array of the same size as the result. Rust’s lazy\niterators tend to get optimized very well.

\n
Examples
\n
let x = [1, 2, 3];\nlet y = x.map(|v| v + 1);\nassert_eq!(y, [2, 3, 4]);\n\nlet x = [1, 2, 3];\nlet mut temp = 0;\nlet y = x.map(|v| { temp += 1; v * temp });\nassert_eq!(y, [1, 4, 9]);\n\nlet x = [\"Ferris\", \"Bueller's\", \"Day\", \"Off\"];\nlet y = x.map(|v| v.len());\nassert_eq!(y, [6, 9, 3, 3]);
\n
source

pub fn try_map<F, R>(\n self,\n f: F\n) -> <<R as Try>::Residual as Residual<[<R as Try>::Output; N]>>::TryType
where\n F: FnMut(T) -> R,\n R: Try,\n <R as Try>::Residual: Residual<[<R as Try>::Output; N]>,

🔬This is a nightly-only experimental API. (array_try_map)

A fallible function f applied to each element on array self in order to\nreturn an array the same size as self or the first error encountered.

\n

The return type of this function depends on the return type of the closure.\nIf you return Result<T, E> from the closure, you’ll get a Result<[T; N], E>.\nIf you return Option<T> from the closure, you’ll get an Option<[T; N]>.

\n
Examples
\n
#![feature(array_try_map)]\nlet a = [\"1\", \"2\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>()).unwrap().map(|v| v + 1);\nassert_eq!(b, [2, 3, 4]);\n\nlet a = [\"1\", \"2a\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>());\nassert!(b.is_err());\n\nuse std::num::NonZeroU32;\nlet z = [1, 2, 0, 3, 4];\nassert_eq!(z.try_map(NonZeroU32::new), None);\nlet a = [1, 2, 3];\nlet b = a.try_map(NonZeroU32::new);\nlet c = b.map(|x| x.map(NonZeroU32::get));\nassert_eq!(c, Some(a));
\n
1.57.0 (const: 1.57.0) · source

pub const fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

\n
1.57.0 · source

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to\n&mut s[..].

\n
source

pub fn each_ref(&self) -> [&T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element and returns an array of references with the same\nsize as self.

\n
Example
\n
#![feature(array_methods)]\n\nlet floats = [3.1, 2.7, -1.0];\nlet float_refs: [&f64; 3] = floats.each_ref();\nassert_eq!(float_refs, [&3.1, &2.7, &-1.0]);
\n

This method is particularly useful if combined with other methods, like\nmap. This way, you can avoid moving the original\narray if its elements are not Copy.

\n\n
#![feature(array_methods)]\n\nlet strings = [\"Ferris\".to_string(), \"♥\".to_string(), \"Rust\".to_string()];\nlet is_ascii = strings.each_ref().map(|s| s.is_ascii());\nassert_eq!(is_ascii, [true, false, true]);\n\n// We can still access the original array: it has not been moved.\nassert_eq!(strings.len(), 3);
\n
source

pub fn each_mut(&mut self) -> [&mut T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element mutably and returns an array of mutable references\nwith the same size as self.

\n
Example
\n
#![feature(array_methods)]\n\nlet mut floats = [3.1, 2.7, -1.0];\nlet float_refs: [&mut f64; 3] = floats.each_mut();\n*float_refs[0] = 0.0;\nassert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);\nassert_eq!(floats, [0.0, 2.7, -1.0]);
\n
source

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

\n

The first will contain all indices from [0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n   let (left, right) = v.split_array_ref::<0>();\n   assert_eq!(left, &[]);\n   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}\n\n{\n    let (left, right) = v.split_array_ref::<2>();\n    assert_eq!(left, &[1, 2]);\n    assert_eq!(right, &[3, 4, 5, 6]);\n}\n\n{\n    let (left, right) = v.split_array_ref::<6>();\n    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n    assert_eq!(right, &[]);\n}
\n
source

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

\n

The first will contain all indices from [0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.split_array_mut::<2>();\nassert_eq!(left, &mut [1, 0][..]);\nassert_eq!(right, &mut [3, 0, 5, 6]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);
\n
source

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

\n

The first will contain all indices from [0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n   let (left, right) = v.rsplit_array_ref::<0>();\n   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n   assert_eq!(right, &[]);\n}\n\n{\n    let (left, right) = v.rsplit_array_ref::<2>();\n    assert_eq!(left, &[1, 2, 3, 4]);\n    assert_eq!(right, &[5, 6]);\n}\n\n{\n    let (left, right) = v.rsplit_array_ref::<6>();\n    assert_eq!(left, &[]);\n    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}
\n
source

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

\n

The first will contain all indices from [0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.rsplit_array_mut::<4>();\nassert_eq!(left, &mut [1, 0]);\nassert_eq!(right, &mut [3, 0, 5, 6][..]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);
\n
",0,"sp_consensus_subspace::offence::Kind"],["
source§

impl<const N: usize> [u8; N]

source

pub const fn as_ascii(&self) -> Option<&[AsciiChar; N]>

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters,\nor returns None if any of the characters is non-ASCII.

\n
Examples
\n
#![feature(ascii_char)]\n#![feature(const_option)]\n\nconst HEX_DIGITS: [std::ascii::Char; 16] =\n    *b\"0123456789abcdef\".as_ascii().unwrap();\n\nassert_eq!(HEX_DIGITS[1].as_str(), \"1\");\nassert_eq!(HEX_DIGITS[10].as_str(), \"a\");
\n
source

pub const unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters,\nwithout checking whether they’re valid.

\n
Safety
\n

Every byte in the array must be in 0..=127, or else this is UB.

\n
",0,"sp_consensus_subspace::offence::Kind"],["
§

impl From<Hash> for [u8; 32]

§

fn from(hash: Hash) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"]], -"subspace_core_primitives":[["
1.4.0 · source§

impl<T, const N: usize> Borrow<[T]> for [T; N]

source§

fn borrow(&self) -> &[T]

Immutably borrows from an owned value. Read more
","Borrow<[T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.50.0 · source§

impl<T, I, const N: usize> IndexMut<I> for [T; N]
where\n [T]: IndexMut<I>,

source§

fn index_mut(&mut self, index: I) -> &mut <[T; N] as Index<I>>::Output

Performs the mutable indexing (container[index]) operation. Read more
","IndexMut","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<T, const N: usize> StructuralEq for [T; N]

","StructuralEq","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> Eq for [T; N]
where\n T: Eq,

","Eq","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.53.0 · source§

impl<T, const N: usize> IntoIterator for [T; N]

source§

fn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter

Creates a consuming iterator, that is, one that moves each value out of\nthe array (from start to end). The array cannot be used after calling\nthis unless T implements Copy, so the whole array is copied.

\n

Arrays have special behavior when calling .into_iter() prior to the\n2021 edition – see the array Editions section for more information.

\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T, N>

Which kind of iterator are we turning this into?
","IntoIterator","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> Ord for [T; N]
where\n T: Ord,

Implements comparison of arrays lexicographically.

\n
source§

fn cmp(&self, other: &[T; N]) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.58.0 · source§

impl<T, const N: usize> Copy for [T; N]
where\n T: Copy,

","Copy","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> AsRef<[T]> for [T; N]

source§

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.
","AsRef<[T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &[B; N]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &[B; N]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<[B; N]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<&[B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &&[B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &&[B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<&[B]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<&mut [B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &&mut [B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &&mut [B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<&mut [B]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<[B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &[B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &[B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<[B]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<T, const N: usize> ConstParamTy for [T; N]
where\n T: ConstParamTy,

","ConstParamTy","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.71.0 · source§

impl<T> From<(T,)> for [T; 1]

source§

fn from(tuple: (T,)) -> [T; 1]

Converts to this type from the input type.
","From<(T,)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T)> for [T; 9]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T)) -> [T; 9]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 12]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T, T)) -> [T; 12]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T)> for [T; 6]

source§

fn from(tuple: (T, T, T, T, T, T)) -> [T; 6]

Converts to this type from the input type.
","From<(T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T)> for [T; 7]

source§

fn from(tuple: (T, T, T, T, T, T, T)) -> [T; 7]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T, T)> for [T; 10]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T, T)) -> [T; 10]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
source§

impl<T, const N: usize> From<Simd<T, N>> for [T; N]
where\n LaneCount<N>: SupportedLaneCount,\n T: SimdElement,

source§

fn from(vector: Simd<T, N>) -> [T; N]

Converts to this type from the input type.
","From>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T)> for [T; 5]

source§

fn from(tuple: (T, T, T, T, T)) -> [T; 5]

Converts to this type from the input type.
","From<(T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T)> for [T; 2]

source§

fn from(tuple: (T, T)) -> [T; 2]

Converts to this type from the input type.
","From<(T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T)> for [T; 11]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T)) -> [T; 11]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T)> for [T; 8]

source§

fn from(tuple: (T, T, T, T, T, T, T, T)) -> [T; 8]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T)> for [T; 4]

source§

fn from(tuple: (T, T, T, T)) -> [T; 4]

Converts to this type from the input type.
","From<(T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T)> for [T; 3]

source§

fn from(tuple: (T, T, T)) -> [T; 3]

Converts to this type from the input type.
","From<(T, T, T)>","subspace_core_primitives::Blake3Hash"],["
source§

impl<T, const N: usize> StructuralPartialEq for [T; N]

","StructuralPartialEq","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 22]
where\n T: Default,

source§

fn default() -> [T; 22]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 21]
where\n T: Default,

source§

fn default() -> [T; 21]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 31]
where\n T: Default,

source§

fn default() -> [T; 31]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 4]
where\n T: Default,

source§

fn default() -> [T; 4]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 9]
where\n T: Default,

source§

fn default() -> [T; 9]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 2]
where\n T: Default,

source§

fn default() -> [T; 2]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 5]
where\n T: Default,

source§

fn default() -> [T; 5]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 7]
where\n T: Default,

source§

fn default() -> [T; 7]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 11]
where\n T: Default,

source§

fn default() -> [T; 11]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 15]
where\n T: Default,

source§

fn default() -> [T; 15]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 27]
where\n T: Default,

source§

fn default() -> [T; 27]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 1]
where\n T: Default,

source§

fn default() -> [T; 1]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 17]
where\n T: Default,

source§

fn default() -> [T; 17]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 20]
where\n T: Default,

source§

fn default() -> [T; 20]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 19]
where\n T: Default,

source§

fn default() -> [T; 19]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 26]
where\n T: Default,

source§

fn default() -> [T; 26]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 25]
where\n T: Default,

source§

fn default() -> [T; 25]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 24]
where\n T: Default,

source§

fn default() -> [T; 24]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 10]
where\n T: Default,

source§

fn default() -> [T; 10]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 0]

source§

fn default() -> [T; 0]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 14]
where\n T: Default,

source§

fn default() -> [T; 14]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 30]
where\n T: Default,

source§

fn default() -> [T; 30]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 12]
where\n T: Default,

source§

fn default() -> [T; 12]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 32]
where\n T: Default,

source§

fn default() -> [T; 32]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 8]
where\n T: Default,

source§

fn default() -> [T; 8]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 13]
where\n T: Default,

source§

fn default() -> [T; 13]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 18]
where\n T: Default,

source§

fn default() -> [T; 18]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 16]
where\n T: Default,

source§

fn default() -> [T; 16]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 6]
where\n T: Default,

source§

fn default() -> [T; 6]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 28]
where\n T: Default,

source§

fn default() -> [T; 28]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 3]
where\n T: Default,

source§

fn default() -> [T; 3]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 29]
where\n T: Default,

source§

fn default() -> [T; 29]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 23]
where\n T: Default,

source§

fn default() -> [T; 23]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.34.0 · source§

impl<T, const N: usize> TryFrom<&[T]> for [T; N]
where\n T: Copy,

Tries to create an array [T; N] by copying from a slice &[T]. Succeeds if\nslice.len() == N.

\n\n
let bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = bytes[1..3].try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));
\n
§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &[T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.
","TryFrom<&[T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.59.0 · source§

impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]
where\n T: Copy,

Tries to create an array [T; N] by copying from a mutable slice &mut [T].\nSucceeds if slice.len() == N.

\n\n
let mut bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&mut bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));
\n
§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &mut [T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.
","TryFrom<&mut [T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> PartialOrd for [T; N]
where\n T: PartialOrd,

source§

fn partial_cmp(&self, other: &[T; N]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
source§

fn lt(&self, other: &[T; N]) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
source§

fn le(&self, other: &[T; N]) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
source§

fn ge(&self, other: &[T; N]) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
source§

fn gt(&self, other: &[T; N]) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
","PartialOrd","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> Hash for [T; N]
where\n T: Hash,

The hash of an array is the same as that of the corresponding slice,\nas required by the Borrow implementation.

\n\n
use std::hash::BuildHasher;\n\nlet b = std::hash::RandomState::new();\nlet a: [u8; 3] = [0xa8, 0x3c, 0x09];\nlet s: &[u8] = &[0xa8, 0x3c, 0x09];\nassert_eq!(b.hash_one(a), b.hash_one(s));
\n
source§

fn hash<H>(&self, state: &mut H)
where\n H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T, const N: usize> BorrowMut<[T]> for [T; N]

source§

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value. Read more
","BorrowMut<[T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.58.0 · source§

impl<T, const N: usize> Clone for [T; N]
where\n T: Clone,

source§

fn clone(&self) -> [T; N]

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, other: &[T; N])

Performs copy-assignment from source. Read more
","Clone","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.50.0 · source§

impl<T, I, const N: usize> Index<I> for [T; N]
where\n [T]: Index<I>,

§

type Output = <[T] as Index<I>>::Output

The returned type after indexing.
source§

fn index(&self, index: I) -> &<[T; N] as Index<I>>::Output

Performs the indexing (container[index]) operation. Read more
","Index","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> Debug for [T; N]
where\n T: Debug,

source§

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

Formats the value using the given formatter. Read more
","Debug","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> AsMut<[T]> for [T; N]

source§

fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.
","AsMut<[T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.51.0 · source§

impl<T, const N: usize> SlicePattern for [T; N]

§

type Item = T

🔬This is a nightly-only experimental API. (slice_pattern)
The element type of the slice being matched on.
source§

fn as_slice(&self) -> &[<[T; N] as SlicePattern>::Item]

🔬This is a nightly-only experimental API. (slice_pattern)
Currently, the consumers of SlicePattern need a slice.
","SlicePattern","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.48.0 · source§

impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]
where\n A: Allocator,

source§

fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>

Gets the entire contents of the Vec<T> as an array,\nif its size exactly matches that of the requested array.

\n
Examples
\n
assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));\nassert_eq!(<Vec<i32>>::new().try_into(), Ok([]));
\n

If the length doesn’t match, the input comes back in Err:

\n\n
let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();\nassert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
\n

If you’re fine with just getting a prefix of the Vec<T>,\nyou can call .truncate(N) first.

\n\n
let mut v = String::from(\"hello world\").into_bytes();\nv.sort();\nv.truncate(2);\nlet [a, b]: [_; 2] = v.try_into().unwrap();\nassert_eq!(a, b' ');\nassert_eq!(b, b'd');
\n
§

type Error = Vec<T, A>

The type returned in the event of a conversion error.
","TryFrom>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, const N: usize> Encode for [T; N]
where\n T: Encode,

§

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
§

fn encode_to<W>(&self, dest: &mut W)
where\n W: Output + ?Sized,

Convert self to a slice and append it to the destination.
§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
§

fn using_encoded<R, F>(&self, f: F) -> R
where\n F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
","Encode","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, const N: usize> MaxEncodedLen for [T; N]
where\n T: MaxEncodedLen,

§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
","MaxEncodedLen","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, U, const N: usize> EncodeLike<[U; N]> for [T; N]
where\n T: EncodeLike<U>,\n U: Encode,

","EncodeLike<[U; N]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, const N: usize> ConstEncodedLen for [T; N]
where\n T: ConstEncodedLen,

","ConstEncodedLen","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, const N: usize> Decode for [T; N]
where\n T: Decode,

§

fn decode<I>(input: &mut I) -> Result<[T; N], Error>
where\n I: Input,

Attempt to deserialise the value from input.
§

fn decode_into<I>(\n input: &mut I,\n dst: &mut MaybeUninit<[T; N]>\n) -> Result<DecodeFinished, Error>
where\n I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory. Read more
§

fn skip<I>(input: &mut I) -> Result<(), Error>
where\n I: Input,

Attempt to skip the encoded value from input. Read more
§

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
","Decode","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<const N: usize> FromByteSlice for [u8; N]

§

fn from_byte_slice<T>(slice: &T) -> Result<&[[u8; N]], Error>
where\n T: AsRef<[u8]> + ?Sized,

Convert from an immutable byte slice to a immutable slice of a fundamental, built-in\nnumeric type
§

fn from_mut_byte_slice<T>(slice: &mut T) -> Result<&mut [[u8; N]], Error>
where\n T: AsMut<[u8]> + ?Sized,

Convert from an mutable byte slice to a mutable slice of a fundamental, built-in numeric\ntype
","FromByteSlice","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<const N: usize> ToMutByteSlice for [u8; N]

§

fn to_mut_byte_slice<T>(slice: &mut T) -> &mut [u8] ⓘ
where\n T: AsMut<[[u8; N]]> + ?Sized,

Convert from a mutable slice of a fundamental, built-in numeric type to a mutable byte\nslice
","ToMutByteSlice","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<const N: usize> ToByteSlice for [u8; N]

§

fn to_byte_slice<T>(slice: &T) -> &[u8] ⓘ
where\n T: AsRef<[[u8; N]]> + ?Sized,

Convert from an immutable slice of a fundamental, built-in numeric type to an immutable\nbyte slice
","ToByteSlice","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 1]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 1], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 28]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 28], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 19]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 19], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 31]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 31], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 26]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 26], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 32]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 32], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 16]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 16], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 14]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 14], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 0]

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 0], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 4]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 4], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 17]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 17], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 12]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 12], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 13]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 13], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 27]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 27], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 23]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 23], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 20]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 20], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 11]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 11], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 2]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 2], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 6]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 6], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 25]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 25], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 15]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 15], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 7]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 7], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 21]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 21], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 24]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 24], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 10]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 10], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 29]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 29], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 9]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 9], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 22]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 22], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 18]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 18], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 8]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 8], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 30]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 30], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 5]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 5], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 3]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 3], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 10]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 30]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 28]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 12]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 32]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<T> Serialize for [T; 18]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 11]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 0]

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 1]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 15]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 6]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 26]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 17]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 9]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 8]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 16]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 22]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 14]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 4]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 23]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 5]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 29]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 27]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 3]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 24]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 20]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 25]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 31]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 2]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 21]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 7]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 19]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 13]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
§

impl<Z, const N: usize> Zeroize for [Z; N]
where\n Z: Zeroize,

Impl [Zeroize] on arrays of types that impl [Zeroize].

\n
§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<Z, const N: usize> ZeroizeOnDrop for [Z; N]
where\n Z: ZeroizeOnDrop,

Impl [ZeroizeOnDrop] on arrays of types that impl [ZeroizeOnDrop].

\n
","ZeroizeOnDrop","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>> for [T; 56]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>\n) -> [T; 56]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>> for [T; 35]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>\n) -> [T; 35]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>> for [T; 57]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>\n) -> [T; 57]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>> for [T; 37]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>\n) -> [T; 37]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>> for [T; 53]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>\n) -> [T; 53]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>> for [T; 50]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>\n) -> [T; 50]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>> for [T; 43]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>\n) -> [T; 43]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>>> for [T; 22]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>>\n) -> [T; 22]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>> for [T; 7]

§

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>) -> [T; 7]

Converts to this type from the input type.
","From, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>>> for [T; 17]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>>\n) -> [T; 17]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>> for [T; 48]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>\n) -> [T; 48]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UTerm, B1>, B1>>> for [T; 3]

§

fn from(sel: GenericArray<T, UInt<UInt<UTerm, B1>, B1>>) -> [T; 3]

Converts to this type from the input type.
","From, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>>> for [T; 28]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>>\n) -> [T; 28]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 300]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>\n) -> [T; 300]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>>> for [T; 23]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>>\n) -> [T; 23]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 1000]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>\n) -> [T; 1000]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>>> for [T; 18]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>>\n) -> [T; 18]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 44]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>\n) -> [T; 44]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 36]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>\n) -> [T; 36]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>> for [T; 8]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>\n) -> [T; 8]

Converts to this type from the input type.
","From, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>> for [T; 5]

§

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>) -> [T; 5]

Converts to this type from the input type.
","From, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>>> for [T; 30]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>>\n) -> [T; 30]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>>> for [T; 31]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>>\n) -> [T; 31]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 100]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>\n) -> [T; 100]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>>> for [T; 29]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>>\n) -> [T; 29]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>>> for [T; 24]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>>\n) -> [T; 24]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>> for [T; 12]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>\n) -> [T; 12]

Converts to this type from the input type.
","From, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 64]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 64]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 1024]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 1024]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>> for [T; 39]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>\n) -> [T; 39]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>> for [T; 16]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>\n) -> [T; 16]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 40]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>\n) -> [T; 40]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 400]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>\n) -> [T; 400]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>> for [T; 90]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>\n) -> [T; 90]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>> for [T; 9]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>\n) -> [T; 9]

Converts to this type from the input type.
","From, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>> for [T; 200]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>\n) -> [T; 200]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>> for [T; 33]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>\n) -> [T; 33]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>>> for [T; 13]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>>\n) -> [T; 13]

Converts to this type from the input type.
","From, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>> for [T; 51]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>\n) -> [T; 51]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>>> for [T; 26]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>>\n) -> [T; 26]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>> for [T; 4]

§

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>) -> [T; 4]

Converts to this type from the input type.
","From, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>> for [T; 63]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>\n) -> [T; 63]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>> for [T; 59]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>\n) -> [T; 59]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 52]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>\n) -> [T; 52]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>> for [T; 55]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>\n) -> [T; 55]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>> for [T; 32]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 32]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T> From<GenericArray<T, UInt<UTerm, B1>>> for [T; 1]

§

fn from(sel: GenericArray<T, UInt<UTerm, B1>>) -> [T; 1]

Converts to this type from the input type.
","From>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>> for [T; 38]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>\n) -> [T; 38]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>> for [T; 45]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>\n) -> [T; 45]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 500]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>\n) -> [T; 500]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 128]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 128]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>> for [T; 54]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>\n) -> [T; 54]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>> for [T; 46]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>\n) -> [T; 46]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>> for [T; 25]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>\n) -> [T; 25]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>> for [T; 34]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>\n) -> [T; 34]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>> for [T; 6]

§

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>) -> [T; 6]

Converts to this type from the input type.
","From, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UTerm, B1>, B0>>> for [T; 2]

§

fn from(sel: GenericArray<T, UInt<UInt<UTerm, B1>, B0>>) -> [T; 2]

Converts to this type from the input type.
","From, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>> for [T; 42]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>\n) -> [T; 42]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 80]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>\n) -> [T; 80]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>> for [T; 60]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>\n) -> [T; 60]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 256]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 256]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>> for [T; 61]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>\n) -> [T; 61]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>> for [T; 47]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>\n) -> [T; 47]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>> for [T; 49]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>\n) -> [T; 49]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>> for [T; 10]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>\n) -> [T; 10]

Converts to this type from the input type.
","From, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>> for [T; 62]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>\n) -> [T; 62]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>> for [T; 70]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>\n) -> [T; 70]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>> for [T; 41]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>\n) -> [T; 41]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>>> for [T; 11]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>>\n) -> [T; 11]

Converts to this type from the input type.
","From, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 512]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 512]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>>> for [T; 19]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>>\n) -> [T; 19]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>> for [T; 20]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>\n) -> [T; 20]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>>> for [T; 21]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>>\n) -> [T; 21]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>> for [T; 58]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>\n) -> [T; 58]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>> for [T; 27]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>\n) -> [T; 27]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>> for [T; 15]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>\n) -> [T; 15]

Converts to this type from the input type.
","From, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>> for [T; 14]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>\n) -> [T; 14]

Converts to this type from the input type.
","From, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T, const N: usize> Array for [T; N]

§

type Item = T

The type of the array’s elements.
§

fn size() -> usize

Returns the number of items the array can hold.
","Array","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, const N: usize> IntoParallelIterator for [T; N]
where\n T: Send,

§

type Item = T

The type of item that the parallel iterator will produce.
§

type Iter = IntoIter<T, N>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <[T; N] as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl FromHex for [u8; 77]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 77], <[u8; 77] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 27]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 27], <[u8; 27] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 4294967296]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 4294967296], <[u8; 4294967296] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 111]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 111], <[u8; 111] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 87]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 87], <[u8; 87] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 46]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 46], <[u8; 46] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 108]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 108], <[u8; 108] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 66]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 66], <[u8; 66] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 99]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 99], <[u8; 99] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 73]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 73], <[u8; 73] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 3]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 3], <[u8; 3] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 123]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 123], <[u8; 123] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 20]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 20], <[u8; 20] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 84]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 84], <[u8; 84] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 268435456]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 268435456], <[u8; 268435456] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 256]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 256], <[u8; 256] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 2]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 2], <[u8; 2] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 38]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 38], <[u8; 38] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 62]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 62], <[u8; 62] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 89]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 89], <[u8; 89] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 384]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 384], <[u8; 384] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 7]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 7], <[u8; 7] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 524288]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 524288], <[u8; 524288] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 125]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 125], <[u8; 125] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 81]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 81], <[u8; 81] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 12]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 12], <[u8; 12] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 101]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 101], <[u8; 101] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 67108864]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 67108864], <[u8; 67108864] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 96]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 96], <[u8; 96] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 69]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 69], <[u8; 69] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 91]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 91], <[u8; 91] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 78]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 78], <[u8; 78] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 116]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 116], <[u8; 116] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 65]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 65], <[u8; 65] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 29]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 29], <[u8; 29] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 53]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 53], <[u8; 53] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 21]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 21], <[u8; 21] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 128]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 128], <[u8; 128] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 51]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 51], <[u8; 51] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 8]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 8], <[u8; 8] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 11]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 11], <[u8; 11] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 67]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 67], <[u8; 67] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 6]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 6], <[u8; 6] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 47]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 47], <[u8; 47] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 192]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 192], <[u8; 192] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 22]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 22], <[u8; 22] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 39]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 39], <[u8; 39] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 262144]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 262144], <[u8; 262144] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 42]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 42], <[u8; 42] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 48]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 48], <[u8; 48] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 71]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 71], <[u8; 71] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 768]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 768], <[u8; 768] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 32]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 32], <[u8; 32] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl FromHex for [u8; 44]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 44], <[u8; 44] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 115]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 115], <[u8; 115] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 9]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 9], <[u8; 9] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 15]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 15], <[u8; 15] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 106]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 106], <[u8; 106] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 64]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 64], <[u8; 64] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 109]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 109], <[u8; 109] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 117]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 117], <[u8; 117] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 93]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 93], <[u8; 93] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 2147483648]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 2147483648], <[u8; 2147483648] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 107]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 107], <[u8; 107] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 16777216]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 16777216], <[u8; 16777216] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 2048]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 2048], <[u8; 2048] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 36]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 36], <[u8; 36] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 131072]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 131072], <[u8; 131072] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 1073741824]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 1073741824], <[u8; 1073741824] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 1]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 1], <[u8; 1] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 40]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 40], <[u8; 40] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 33]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 33], <[u8; 33] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 37]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 37], <[u8; 37] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 61]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 61], <[u8; 61] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 26]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 26], <[u8; 26] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 104]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 104], <[u8; 104] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 100]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 100], <[u8; 100] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 113]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 113], <[u8; 113] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 83]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 83], <[u8; 83] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 1024]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 1024], <[u8; 1024] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 88]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 88], <[u8; 88] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 126]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 126], <[u8; 126] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 68]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 68], <[u8; 68] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 5]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 5], <[u8; 5] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 41]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 41], <[u8; 41] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 25]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 25], <[u8; 25] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 85]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 85], <[u8; 85] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 102]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 102], <[u8; 102] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 1048576]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 1048576], <[u8; 1048576] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 200]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 200], <[u8; 200] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 30]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 30], <[u8; 30] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 90]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 90], <[u8; 90] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 70]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 70], <[u8; 70] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 72]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 72], <[u8; 72] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 127]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 127], <[u8; 127] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 134217728]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 134217728], <[u8; 134217728] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 58]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 58], <[u8; 58] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 92]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 92], <[u8; 92] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 105]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 105], <[u8; 105] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 16384]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 16384], <[u8; 16384] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 79]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 79], <[u8; 79] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 32768]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 32768], <[u8; 32768] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 121]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 121], <[u8; 121] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 224]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 224], <[u8; 224] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 160]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 160], <[u8; 160] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 80]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 80], <[u8; 80] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 2097152]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 2097152], <[u8; 2097152] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 23]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 23], <[u8; 23] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 512]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 512], <[u8; 512] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 76]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 76], <[u8; 76] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 4]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 4], <[u8; 4] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 31]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 31], <[u8; 31] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 16]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 16], <[u8; 16] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 35]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 35], <[u8; 35] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 98]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 98], <[u8; 98] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 97]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 97], <[u8; 97] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 94]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 94], <[u8; 94] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 63]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 63], <[u8; 63] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 65536]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 65536], <[u8; 65536] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 49]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 49], <[u8; 49] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 50]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 50], <[u8; 50] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 119]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 119], <[u8; 119] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 52]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 52], <[u8; 52] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 8192]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 8192], <[u8; 8192] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 74]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 74], <[u8; 74] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 118]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 118], <[u8; 118] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 112]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 112], <[u8; 112] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 34]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 34], <[u8; 34] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 75]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 75], <[u8; 75] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 122]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 122], <[u8; 122] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 43]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 43], <[u8; 43] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 17]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 17], <[u8; 17] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 28]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 28], <[u8; 28] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 536870912]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 536870912], <[u8; 536870912] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 60]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 60], <[u8; 60] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 124]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 124], <[u8; 124] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 13]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 13], <[u8; 13] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 14]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 14], <[u8; 14] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 114]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 114], <[u8; 114] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 95]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 95], <[u8; 95] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 55]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 55], <[u8; 55] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 45]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 45], <[u8; 45] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 57]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 57], <[u8; 57] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 18]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 18], <[u8; 18] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 24]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 24], <[u8; 24] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 59]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 59], <[u8; 59] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 120]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 120], <[u8; 120] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 103]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 103], <[u8; 103] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 19]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 19], <[u8; 19] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 8388608]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 8388608], <[u8; 8388608] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 4096]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 4096], <[u8; 4096] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 86]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 86], <[u8; 86] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 54]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 54], <[u8; 54] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 82]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 82], <[u8; 82] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 110]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 110], <[u8; 110] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 56]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 56], <[u8; 56] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 4194304]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 4194304], <[u8; 4194304] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 33554432]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 33554432], <[u8; 33554432] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 10]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 10], <[u8; 10] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
§

impl<T, const N: usize> TypeInfo for [T; N]
where\n T: TypeInfo + 'static,

§

type Identity = [T; N]

The type identifying for which type info is provided. Read more
§

fn type_info() -> Type

Returns the static type identifier for Self.
","TypeInfo","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl From<Hash> for [u8; 32]

§

fn from(hash: Hash) -> [u8; 32]

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<&Scalar> for [u8; 32]

source§

fn from(value: &Scalar) -> Self

Converts to this type from the input type.
","From<&Scalar>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<T, const N: usize> [T; N]

1.55.0 · source

pub fn map<F, U>(self, f: F) -> [U; N]
where\n F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element\nin order.

\n

If you don’t necessarily need a new fixed-size array, consider using\nIterator::map instead.

\n
Note on performance and stack usage
\n

Unfortunately, usages of this method are currently not always optimized\nas well as they could be. This mainly concerns large arrays, as mapping\nover small arrays seem to be optimized just fine. Also note that in\ndebug mode (i.e. without any optimizations), this method can use a lot\nof stack space (a few times the size of the array or more).

\n

Therefore, in performance-critical code, try to avoid using this method\non large arrays or check the emitted code. Also try to avoid chained\nmaps (e.g. arr.map(...).map(...)).

\n

In many cases, you can instead use Iterator::map by calling .iter()\nor .into_iter() on your array. [T; N]::map is only necessary if you\nreally need a new array of the same size as the result. Rust’s lazy\niterators tend to get optimized very well.

\n
Examples
\n
let x = [1, 2, 3];\nlet y = x.map(|v| v + 1);\nassert_eq!(y, [2, 3, 4]);\n\nlet x = [1, 2, 3];\nlet mut temp = 0;\nlet y = x.map(|v| { temp += 1; v * temp });\nassert_eq!(y, [1, 4, 9]);\n\nlet x = [\"Ferris\", \"Bueller's\", \"Day\", \"Off\"];\nlet y = x.map(|v| v.len());\nassert_eq!(y, [6, 9, 3, 3]);
\n
source

pub fn try_map<F, R>(\n self,\n f: F\n) -> <<R as Try>::Residual as Residual<[<R as Try>::Output; N]>>::TryType
where\n F: FnMut(T) -> R,\n R: Try,\n <R as Try>::Residual: Residual<[<R as Try>::Output; N]>,

🔬This is a nightly-only experimental API. (array_try_map)

A fallible function f applied to each element on array self in order to\nreturn an array the same size as self or the first error encountered.

\n

The return type of this function depends on the return type of the closure.\nIf you return Result<T, E> from the closure, you’ll get a Result<[T; N], E>.\nIf you return Option<T> from the closure, you’ll get an Option<[T; N]>.

\n
Examples
\n
#![feature(array_try_map)]\nlet a = [\"1\", \"2\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>()).unwrap().map(|v| v + 1);\nassert_eq!(b, [2, 3, 4]);\n\nlet a = [\"1\", \"2a\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>());\nassert!(b.is_err());\n\nuse std::num::NonZeroU32;\nlet z = [1, 2, 0, 3, 4];\nassert_eq!(z.try_map(NonZeroU32::new), None);\nlet a = [1, 2, 3];\nlet b = a.try_map(NonZeroU32::new);\nlet c = b.map(|x| x.map(NonZeroU32::get));\nassert_eq!(c, Some(a));
\n
1.57.0 (const: 1.57.0) · source

pub const fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

\n
1.57.0 · source

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to\n&mut s[..].

\n
source

pub fn each_ref(&self) -> [&T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element and returns an array of references with the same\nsize as self.

\n
Example
\n
#![feature(array_methods)]\n\nlet floats = [3.1, 2.7, -1.0];\nlet float_refs: [&f64; 3] = floats.each_ref();\nassert_eq!(float_refs, [&3.1, &2.7, &-1.0]);
\n

This method is particularly useful if combined with other methods, like\nmap. This way, you can avoid moving the original\narray if its elements are not Copy.

\n\n
#![feature(array_methods)]\n\nlet strings = [\"Ferris\".to_string(), \"♥\".to_string(), \"Rust\".to_string()];\nlet is_ascii = strings.each_ref().map(|s| s.is_ascii());\nassert_eq!(is_ascii, [true, false, true]);\n\n// We can still access the original array: it has not been moved.\nassert_eq!(strings.len(), 3);
\n
source

pub fn each_mut(&mut self) -> [&mut T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element mutably and returns an array of mutable references\nwith the same size as self.

\n
Example
\n
#![feature(array_methods)]\n\nlet mut floats = [3.1, 2.7, -1.0];\nlet float_refs: [&mut f64; 3] = floats.each_mut();\n*float_refs[0] = 0.0;\nassert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);\nassert_eq!(floats, [0.0, 2.7, -1.0]);
\n
source

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

\n

The first will contain all indices from [0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n   let (left, right) = v.split_array_ref::<0>();\n   assert_eq!(left, &[]);\n   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}\n\n{\n    let (left, right) = v.split_array_ref::<2>();\n    assert_eq!(left, &[1, 2]);\n    assert_eq!(right, &[3, 4, 5, 6]);\n}\n\n{\n    let (left, right) = v.split_array_ref::<6>();\n    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n    assert_eq!(right, &[]);\n}
\n
source

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

\n

The first will contain all indices from [0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.split_array_mut::<2>();\nassert_eq!(left, &mut [1, 0][..]);\nassert_eq!(right, &mut [3, 0, 5, 6]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);
\n
source

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

\n

The first will contain all indices from [0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n   let (left, right) = v.rsplit_array_ref::<0>();\n   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n   assert_eq!(right, &[]);\n}\n\n{\n    let (left, right) = v.rsplit_array_ref::<2>();\n    assert_eq!(left, &[1, 2, 3, 4]);\n    assert_eq!(right, &[5, 6]);\n}\n\n{\n    let (left, right) = v.rsplit_array_ref::<6>();\n    assert_eq!(left, &[]);\n    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}
\n
source

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

\n

The first will contain all indices from [0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.rsplit_array_mut::<4>();\nassert_eq!(left, &mut [1, 0]);\nassert_eq!(right, &mut [3, 0, 5, 6][..]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);
\n
",0,"subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<const N: usize> [u8; N]

source

pub const fn as_ascii(&self) -> Option<&[AsciiChar; N]>

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters,\nor returns None if any of the characters is non-ASCII.

\n
Examples
\n
#![feature(ascii_char)]\n#![feature(const_option)]\n\nconst HEX_DIGITS: [std::ascii::Char; 16] =\n    *b\"0123456789abcdef\".as_ascii().unwrap();\n\nassert_eq!(HEX_DIGITS[1].as_str(), \"1\");\nassert_eq!(HEX_DIGITS[10].as_str(), \"a\");
\n
source

pub const unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters,\nwithout checking whether they’re valid.

\n
Safety
\n

Every byte in the array must be in 0..=127, or else this is UB.

\n
",0,"subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<SegmentCommitment> for [u8; 48]

source§

fn from(original: SegmentCommitment) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<Witness> for [u8; 48]

source§

fn from(witness: Witness) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<RecordCommitment> for [u8; 48]

source§

fn from(original: RecordCommitment) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<PublicKey> for [u8; 32]

source§

fn from(original: PublicKey) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<Scalar> for [u8; 32]

source§

fn from(value: Scalar) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<RewardSignature> for [u8; 64]

source§

fn from(original: RewardSignature) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<PosSeed> for [u8; 32]

source§

fn from(value: PosSeed) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<PosProof> for [u8; 160]

source§

fn from(value: PosProof) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<ChunkWitness> for [u8; 48]

source§

fn from(original: ChunkWitness) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<RecordWitness> for [u8; 48]

source§

fn from(original: RecordWitness) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<&Witness> for [u8; 48]

source§

fn from(witness: &Witness) -> Self

Converts to this type from the input type.
","From<&Witness>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<&Commitment> for [u8; 48]

source§

fn from(commitment: &Commitment) -> Self

Converts to this type from the input type.
","From<&Commitment>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<Commitment> for [u8; 48]

source§

fn from(commitment: Commitment) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<Randomness> for [u8; 32]

source§

fn from(original: Randomness) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"]] +"sp_consensus_subspace":[["
1.4.0 · source§

impl<T, const N: usize> Borrow<[T]> for [T; N]

source§

fn borrow(&self) -> &[T]

Immutably borrows from an owned value. Read more
","Borrow<[T]>","sp_consensus_subspace::offence::Kind"],["
1.50.0 · source§

impl<T, I, const N: usize> IndexMut<I> for [T; N]
where\n [T]: IndexMut<I>,

source§

fn index_mut(&mut self, index: I) -> &mut <[T; N] as Index<I>>::Output

Performs the mutable indexing (container[index]) operation. Read more
","IndexMut","sp_consensus_subspace::offence::Kind"],["
source§

impl<T, const N: usize> StructuralEq for [T; N]

","StructuralEq","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> Eq for [T; N]
where\n T: Eq,

","Eq","sp_consensus_subspace::offence::Kind"],["
1.53.0 · source§

impl<T, const N: usize> IntoIterator for [T; N]

source§

fn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter

Creates a consuming iterator, that is, one that moves each value out of\nthe array (from start to end). The array cannot be used after calling\nthis unless T implements Copy, so the whole array is copied.

\n

Arrays have special behavior when calling .into_iter() prior to the\n2021 edition – see the array Editions section for more information.

\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T, N>

Which kind of iterator are we turning this into?
","IntoIterator","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> Ord for [T; N]
where\n T: Ord,

Implements comparison of arrays lexicographically.

\n
source§

fn cmp(&self, other: &[T; N]) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","sp_consensus_subspace::offence::Kind"],["
1.58.0 · source§

impl<T, const N: usize> Copy for [T; N]
where\n T: Copy,

","Copy","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> AsRef<[T]> for [T; N]

source§

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.
","AsRef<[T]>","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &[B; N]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &[B; N]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<[B; N]>","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<&[B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &&[B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &&[B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<&[B]>","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<&mut [B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &&mut [B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &&mut [B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<&mut [B]>","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<[B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &[B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &[B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<[B]>","sp_consensus_subspace::offence::Kind"],["
source§

impl<T, const N: usize> ConstParamTy for [T; N]
where\n T: ConstParamTy,

","ConstParamTy","sp_consensus_subspace::offence::Kind"],["
source§

impl<T, const N: usize> From<Simd<T, N>> for [T; N]
where\n LaneCount<N>: SupportedLaneCount,\n T: SimdElement,

source§

fn from(vector: Simd<T, N>) -> [T; N]

Converts to this type from the input type.
","From>","sp_consensus_subspace::offence::Kind"],["
source§

impl<T, const N: usize> StructuralPartialEq for [T; N]

","StructuralPartialEq","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 22]
where\n T: Default,

source§

fn default() -> [T; 22]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 21]
where\n T: Default,

source§

fn default() -> [T; 21]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 31]
where\n T: Default,

source§

fn default() -> [T; 31]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 4]
where\n T: Default,

source§

fn default() -> [T; 4]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 9]
where\n T: Default,

source§

fn default() -> [T; 9]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 2]
where\n T: Default,

source§

fn default() -> [T; 2]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 5]
where\n T: Default,

source§

fn default() -> [T; 5]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 7]
where\n T: Default,

source§

fn default() -> [T; 7]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 11]
where\n T: Default,

source§

fn default() -> [T; 11]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 15]
where\n T: Default,

source§

fn default() -> [T; 15]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 27]
where\n T: Default,

source§

fn default() -> [T; 27]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 1]
where\n T: Default,

source§

fn default() -> [T; 1]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 17]
where\n T: Default,

source§

fn default() -> [T; 17]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 20]
where\n T: Default,

source§

fn default() -> [T; 20]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 19]
where\n T: Default,

source§

fn default() -> [T; 19]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 26]
where\n T: Default,

source§

fn default() -> [T; 26]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 25]
where\n T: Default,

source§

fn default() -> [T; 25]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 24]
where\n T: Default,

source§

fn default() -> [T; 24]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 10]
where\n T: Default,

source§

fn default() -> [T; 10]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 0]

source§

fn default() -> [T; 0]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 14]
where\n T: Default,

source§

fn default() -> [T; 14]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 30]
where\n T: Default,

source§

fn default() -> [T; 30]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 12]
where\n T: Default,

source§

fn default() -> [T; 12]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 8]
where\n T: Default,

source§

fn default() -> [T; 8]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 13]
where\n T: Default,

source§

fn default() -> [T; 13]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 18]
where\n T: Default,

source§

fn default() -> [T; 18]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 16]
where\n T: Default,

source§

fn default() -> [T; 16]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 6]
where\n T: Default,

source§

fn default() -> [T; 6]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 28]
where\n T: Default,

source§

fn default() -> [T; 28]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 3]
where\n T: Default,

source§

fn default() -> [T; 3]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 29]
where\n T: Default,

source§

fn default() -> [T; 29]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T> Default for [T; 23]
where\n T: Default,

source§

fn default() -> [T; 23]

Returns the “default value” for a type. Read more
","Default","sp_consensus_subspace::offence::Kind"],["
1.34.0 · source§

impl<T, const N: usize> TryFrom<&[T]> for [T; N]
where\n T: Copy,

Tries to create an array [T; N] by copying from a slice &[T]. Succeeds if\nslice.len() == N.

\n\n
let bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = bytes[1..3].try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));
\n
§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &[T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.
","TryFrom<&[T]>","sp_consensus_subspace::offence::Kind"],["
1.59.0 · source§

impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]
where\n T: Copy,

Tries to create an array [T; N] by copying from a mutable slice &mut [T].\nSucceeds if slice.len() == N.

\n\n
let mut bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&mut bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));
\n
§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &mut [T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.
","TryFrom<&mut [T]>","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> PartialOrd for [T; N]
where\n T: PartialOrd,

source§

fn partial_cmp(&self, other: &[T; N]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
source§

fn lt(&self, other: &[T; N]) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
source§

fn le(&self, other: &[T; N]) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
source§

fn ge(&self, other: &[T; N]) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
source§

fn gt(&self, other: &[T; N]) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
","PartialOrd","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> Hash for [T; N]
where\n T: Hash,

The hash of an array is the same as that of the corresponding slice,\nas required by the Borrow implementation.

\n\n
use std::hash::BuildHasher;\n\nlet b = std::hash::RandomState::new();\nlet a: [u8; 3] = [0xa8, 0x3c, 0x09];\nlet s: &[u8] = &[0xa8, 0x3c, 0x09];\nassert_eq!(b.hash_one(a), b.hash_one(s));
\n
source§

fn hash<H>(&self, state: &mut H)
where\n H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","sp_consensus_subspace::offence::Kind"],["
1.4.0 · source§

impl<T, const N: usize> BorrowMut<[T]> for [T; N]

source§

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value. Read more
","BorrowMut<[T]>","sp_consensus_subspace::offence::Kind"],["
1.58.0 · source§

impl<T, const N: usize> Clone for [T; N]
where\n T: Clone,

source§

fn clone(&self) -> [T; N]

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, other: &[T; N])

Performs copy-assignment from source. Read more
","Clone","sp_consensus_subspace::offence::Kind"],["
1.50.0 · source§

impl<T, I, const N: usize> Index<I> for [T; N]
where\n [T]: Index<I>,

§

type Output = <[T] as Index<I>>::Output

The returned type after indexing.
source§

fn index(&self, index: I) -> &<[T; N] as Index<I>>::Output

Performs the indexing (container[index]) operation. Read more
","Index","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> Debug for [T; N]
where\n T: Debug,

source§

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

Formats the value using the given formatter. Read more
","Debug","sp_consensus_subspace::offence::Kind"],["
1.0.0 · source§

impl<T, const N: usize> AsMut<[T]> for [T; N]

source§

fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.
","AsMut<[T]>","sp_consensus_subspace::offence::Kind"],["
1.51.0 · source§

impl<T, const N: usize> SlicePattern for [T; N]

§

type Item = T

🔬This is a nightly-only experimental API. (slice_pattern)
The element type of the slice being matched on.
source§

fn as_slice(&self) -> &[<[T; N] as SlicePattern>::Item]

🔬This is a nightly-only experimental API. (slice_pattern)
Currently, the consumers of SlicePattern need a slice.
","SlicePattern","sp_consensus_subspace::offence::Kind"],["
1.48.0 · source§

impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]
where\n A: Allocator,

source§

fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>

Gets the entire contents of the Vec<T> as an array,\nif its size exactly matches that of the requested array.

\n
Examples
\n
assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));\nassert_eq!(<Vec<i32>>::new().try_into(), Ok([]));
\n

If the length doesn’t match, the input comes back in Err:

\n\n
let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();\nassert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
\n

If you’re fine with just getting a prefix of the Vec<T>,\nyou can call .truncate(N) first.

\n\n
let mut v = String::from(\"hello world\").into_bytes();\nv.sort();\nv.truncate(2);\nlet [a, b]: [_; 2] = v.try_into().unwrap();\nassert_eq!(a, b' ');\nassert_eq!(b, b'd');
\n
§

type Error = Vec<T, A>

The type returned in the event of a conversion error.
","TryFrom>","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> Encode for [T; N]
where\n T: Encode,

§

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
§

fn encode_to<W>(&self, dest: &mut W)
where\n W: Output + ?Sized,

Convert self to a slice and append it to the destination.
§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
§

fn using_encoded<R, F>(&self, f: F) -> R
where\n F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
","Encode","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> MaxEncodedLen for [T; N]
where\n T: MaxEncodedLen,

§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
","MaxEncodedLen","sp_consensus_subspace::offence::Kind"],["
§

impl<T, U, const N: usize> EncodeLike<[U; N]> for [T; N]
where\n T: EncodeLike<U>,\n U: Encode,

","EncodeLike<[U; N]>","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> ConstEncodedLen for [T; N]
where\n T: ConstEncodedLen,

","ConstEncodedLen","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> Decode for [T; N]
where\n T: Decode,

§

fn decode<I>(input: &mut I) -> Result<[T; N], Error>
where\n I: Input,

Attempt to deserialise the value from input.
§

fn decode_into<I>(\n input: &mut I,\n dst: &mut MaybeUninit<[T; N]>\n) -> Result<DecodeFinished, Error>
where\n I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory. Read more
§

fn skip<I>(input: &mut I) -> Result<(), Error>
where\n I: Input,

Attempt to skip the encoded value from input. Read more
§

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
","Decode","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> FromByteSlice for [u8; N]

§

fn from_byte_slice<T>(slice: &T) -> Result<&[[u8; N]], Error>
where\n T: AsRef<[u8]> + ?Sized,

Convert from an immutable byte slice to a immutable slice of a fundamental, built-in\nnumeric type
§

fn from_mut_byte_slice<T>(slice: &mut T) -> Result<&mut [[u8; N]], Error>
where\n T: AsMut<[u8]> + ?Sized,

Convert from an mutable byte slice to a mutable slice of a fundamental, built-in numeric\ntype
","FromByteSlice","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> ToMutByteSlice for [u8; N]

§

fn to_mut_byte_slice<T>(slice: &mut T) -> &mut [u8] ⓘ
where\n T: AsMut<[[u8; N]]> + ?Sized,

Convert from a mutable slice of a fundamental, built-in numeric type to a mutable byte\nslice
","ToMutByteSlice","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> ToByteSlice for [u8; N]

§

fn to_byte_slice<T>(slice: &T) -> &[u8] ⓘ
where\n T: AsRef<[[u8; N]]> + ?Sized,

Convert from an immutable slice of a fundamental, built-in numeric type to an immutable\nbyte slice
","ToByteSlice","sp_consensus_subspace::offence::Kind"],["
source§

impl<'de, T> Deserialize<'de> for [T; 16]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 16], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Serialize for [T; 16]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> TypeInfo for [T; N]
where\n T: TypeInfo + 'static,

§

type Identity = [T; N]

The type identifying for which type info is provided. Read more
§

fn type_info() -> Type

Returns the static type identifier for Self.
","TypeInfo","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> Printable for [u8; N]

§

fn print(&self)

Print the object.
","Printable","sp_consensus_subspace::offence::Kind"],["
§

impl AsBytesRef for [u8; 16]

§

fn as_bytes_ref(&self) -> &[u8] ⓘ

Transform self into &[u8].
","AsBytesRef","sp_consensus_subspace::offence::Kind"],["
§

impl<const LEFT_PLUS_RIGHT_LEN: usize> From<Signature<LEFT_PLUS_RIGHT_LEN>> for [u8; LEFT_PLUS_RIGHT_LEN]

§

fn from(signature: Signature<LEFT_PLUS_RIGHT_LEN>) -> [u8; LEFT_PLUS_RIGHT_LEN]

Converts to this type from the input type.
","From>","sp_consensus_subspace::offence::Kind"],["
§

impl From<Signature> for [u8; 65]

§

fn from(v: Signature) -> [u8; 65]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
§

impl FromEntropy for [u8; 16]

§

fn from_entropy(input: &mut impl Input) -> Result<[u8; 16], Error>

Create a random value of Self given a stream of random bytes on input. May only fail if\ninput has an error.
","FromEntropy","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> IntoPreallocatedFFIValue for [u8; N]

§

type SelfInstance = [u8; N]

As Self can be an unsized type, it needs to be represented by a sized type at the host.\nThis SelfInstance is the sized type.
§

fn into_preallocated_ffi_value(\n self_instance: <[u8; N] as IntoPreallocatedFFIValue>::SelfInstance,\n context: &mut dyn FunctionContext,\n allocated: u32\n) -> Result<(), String>

Convert self_instance into the given preallocated ffi value.
","IntoPreallocatedFFIValue","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> RIType for [u8; N]

The type is passed as u32.

\n

The u32 is the pointer to the array.

\n
§

type FFIType = u32

The ffi type that is used to represent Self.
","RIType","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> IntoFFIValue for [u8; N]

§

fn into_ffi_value(\n self,\n context: &mut dyn FunctionContext\n) -> Result<u32, String>

Convert self into a ffi value.
","IntoFFIValue","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> FromFFIValue for [u8; N]

§

type SelfInstance = [u8; N]

As Self can be an unsized type, it needs to be represented by a sized type at the host.\nThis SelfInstance is the sized type.
§

fn from_ffi_value(\n context: &mut dyn FunctionContext,\n arg: u32\n) -> Result<[u8; N], String>

Create SelfInstance from the given
","FromFFIValue","sp_consensus_subspace::offence::Kind"],["
§

impl<T> Array for [T; 16]
where\n T: Default,

§

type Item = T

The type of the items in the thing.
§

const CAPACITY: usize = 16usize

The number of slots in the thing.
§

fn as_slice(&self) -> &[T]

Gives a shared slice over the whole thing. Read more
§

fn as_slice_mut(&mut self) -> &mut [T]

Gives a unique slice over the whole thing. Read more
§

fn default() -> [T; 16]

Create a default-initialized instance of ourself, similar to the\nDefault trait, but implemented for the same range of sizes as\n[Array].
","Array","sp_consensus_subspace::offence::Kind"],["
§

impl<T> ArrayLike for [T; 16]

§

type Item = T

Type of the elements being stored.
","ArrayLike","sp_consensus_subspace::offence::Kind"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>> for [T; 16]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>\n) -> [T; 16]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>>>","sp_consensus_subspace::offence::Kind"],["
§

impl<Z, const N: usize> Zeroize for [Z; N]
where\n Z: Zeroize,

Impl [Zeroize] on arrays of types that impl [Zeroize].

\n
§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","sp_consensus_subspace::offence::Kind"],["
§

impl<Z, const N: usize> ZeroizeOnDrop for [Z; N]
where\n Z: ZeroizeOnDrop,

Impl [ZeroizeOnDrop] on arrays of types that impl [ZeroizeOnDrop].

\n
","ZeroizeOnDrop","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> Replacer for [u8; N]

§

fn replace_append(&mut self, caps: &Captures<'_>, dst: &mut Vec<u8>)

Appends possibly empty data to dst to replace the current match. Read more
§

fn no_expansion(&mut self) -> Option<Cow<'_, [u8]>>

Return a fixed unchanging replacement byte string. Read more
§

fn by_ref<'r>(&'r mut self) -> ReplacerRef<'r, Self>

Returns a type that implements Replacer, but that borrows and wraps\nthis Replacer. Read more
","Replacer","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> IntoParallelIterator for [T; N]
where\n T: Send,

§

type Item = T

The type of item that the parallel iterator will produce.
§

type Iter = IntoIter<T, N>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <[T; N] as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","sp_consensus_subspace::offence::Kind"],["
§

impl<T, const N: usize> Array for [T; N]

§

type Item = T

The type of the array’s elements.
§

fn size() -> usize

Returns the number of items the array can hold.
","Array","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize, T> FromBytes for [T; N]
where\n T: FromBytes,

§

fn ref_from(bytes: &[u8]) -> Option<&Self>
where\n Self: Sized,

Interprets the given bytes as a &Self without copying. Read more
§

fn ref_from_prefix(bytes: &[u8]) -> Option<&Self>
where\n Self: Sized,

Interprets the prefix of the given bytes as a &Self without copying. Read more
§

fn ref_from_suffix(bytes: &[u8]) -> Option<&Self>
where\n Self: Sized,

Interprets the suffix of the given bytes as a &Self without copying. Read more
§

fn slice_from(bytes: &[u8]) -> Option<&[Self]>
where\n Self: Sized,

Interprets the given bytes as a &[Self] without copying. Read more
§

fn slice_from_prefix(bytes: &[u8], count: usize) -> Option<(&[Self], &[u8])>
where\n Self: Sized,

Interprets the prefix of the given bytes as a &[Self] with length\nequal to count without copying. Read more
§

fn slice_from_suffix(bytes: &[u8], count: usize) -> Option<(&[u8], &[Self])>
where\n Self: Sized,

Interprets the suffix of the given bytes as a &[Self] with length\nequal to count without copying. Read more
§

fn read_from(bytes: &[u8]) -> Option<Self>
where\n Self: Sized,

Reads a copy of Self from bytes. Read more
§

fn read_from_prefix(bytes: &[u8]) -> Option<Self>
where\n Self: Sized,

Reads a copy of Self from the prefix of bytes. Read more
§

fn read_from_suffix(bytes: &[u8]) -> Option<Self>
where\n Self: Sized,

Reads a copy of Self from the suffix of bytes. Read more
","FromBytes","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize, T> Unaligned for [T; N]
where\n T: Unaligned,

","Unaligned","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize, T> FromZeroes for [T; N]
where\n T: FromZeroes,

§

fn zero(&mut self)

Overwrites self with zeroes. Read more
§

fn new_zeroed() -> Self
where\n Self: Sized,

Creates an instance of Self from zeroed bytes. Read more
","FromZeroes","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize, T> AsBytes for [T; N]
where\n T: AsBytes,

§

fn as_bytes(&self) -> &[u8] ⓘ

Gets the bytes of this value. Read more
§

fn write_to(&self, bytes: &mut [u8]) -> Option<()>

Writes a copy of self to bytes. Read more
§

fn write_to_prefix(&self, bytes: &mut [u8]) -> Option<()>

Writes a copy of self to the prefix of bytes. Read more
§

fn write_to_suffix(&self, bytes: &mut [u8]) -> Option<()>

Writes a copy of self to the suffix of bytes. Read more
","AsBytes","sp_consensus_subspace::offence::Kind"],["
§

impl From<U256> for [u8; 32]

§

fn from(number: U256) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
§

impl From<U512> for [u8; 64]

§

fn from(number: U512) -> [u8; 64]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
§

impl From<U128> for [u8; 16]

§

fn from(number: U128) -> [u8; 16]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
§

impl From<H128> for [u8; 16]

§

fn from(s: H128) -> [u8; 16]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 21]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 26]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 9]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 16]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 64]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 11]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 10]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 1024]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 4]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 27]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 7]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 128]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 19]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 23]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 2048]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 512]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 1]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 28]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 31]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 12]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 20]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 0]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 15]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 17]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 29]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 8]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 18]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 3]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 13]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 24]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 14]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 30]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 256]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 25]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 5]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 6]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 2]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> Fill for [T; 22]
where\n [T]: Fill,

source§

fn try_fill<R>(&mut self, rng: &mut R) -> Result<(), Error>
where\n R: Rng + ?Sized,

Fill self with random data
","Fill","sp_consensus_subspace::offence::Kind"],["
source§

impl FromHex for [u8; 16]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 16], <[u8; 16] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","sp_consensus_subspace::offence::Kind"],["
§

impl FromHex for [u8; 16]

§

fn from_byte_iter<I>(iter: I) -> Result<[u8; 16], Error>
where\n I: Iterator<Item = Result<u8, Error>> + ExactSizeIterator + DoubleEndedIterator,

Produces an object from a byte iterator.
§

fn from_hex(s: &str) -> Result<Self, Error>

Produces an object from a hex string.
","FromHex","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> DebugSecret for [T; 16]
where\n T: Debug,

source§

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

Format information about the secret’s type. Read more
","DebugSecret","sp_consensus_subspace::offence::Kind"],["
source§

impl<T> CloneableSecret for [T; 16]
where\n T: Clone + Zeroize,

","CloneableSecret","sp_consensus_subspace::offence::Kind"],["
§

impl<const N: usize> DecodeTarget for [u8; N]

§

fn decode_with(\n &mut self,\n max_len: usize,\n f: impl for<'a> FnOnce(&'a mut [u8]) -> Result<usize, Error>\n) -> Result<usize, Error>

Decodes into this buffer, provides the maximum length for implementations that wish to\npreallocate space, along with a function that will write bytes into the buffer and return\nthe length written to it.
","DecodeTarget","sp_consensus_subspace::offence::Kind"],["
§

impl Hex for [u8; 16]

§

fn hex(self, prefix: &str) -> String

Convert [Self] to hex with the given prefix.
","Hex","sp_consensus_subspace::offence::Kind"],["
§

impl TryFromHex for [u8; 16]

§

fn try_from_hex<H>(hex: H) -> Result<[u8; 16], Error>
where\n H: AsRef<[u8]>,

Try to convert [Self] from hex.
","TryFromHex","sp_consensus_subspace::offence::Kind"],["
§

impl From<&Signature> for [u8; 64]

§

fn from(sig: &Signature) -> [u8; 64]

Converts to this type from the input type.
","From<&Signature>","sp_consensus_subspace::offence::Kind"],["
§

impl From<Signature> for [u8; 64]

§

fn from(sig: Signature) -> [u8; 64]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
§

impl<T> ArrayLike for [T; 16]

§

type Item = T

Type of the elements being stored.
","ArrayLike","sp_consensus_subspace::offence::Kind"],["
source§

impl From<&Scalar> for [u8; 32]

source§

fn from(value: &Scalar) -> [u8; 32]

Converts to this type from the input type.
","From<&Scalar>","sp_consensus_subspace::offence::Kind"],["
source§

impl From<SegmentCommitment> for [u8; 48]

source§

fn from(original: SegmentCommitment) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<Witness> for [u8; 48]

source§

fn from(witness: Witness) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<RecordCommitment> for [u8; 48]

source§

fn from(original: RecordCommitment) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<PublicKey> for [u8; 32]

source§

fn from(original: PublicKey) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<Scalar> for [u8; 32]

source§

fn from(value: Scalar) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<RewardSignature> for [u8; 64]

source§

fn from(original: RewardSignature) -> [u8; 64]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<PosSeed> for [u8; 32]

source§

fn from(value: PosSeed) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<PosProof> for [u8; 160]

source§

fn from(value: PosProof) -> [u8; 160]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<ChunkWitness> for [u8; 48]

source§

fn from(original: ChunkWitness) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<U256> for [u8; 32]

source§

fn from(number: U256) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<RecordWitness> for [u8; 48]

source§

fn from(original: RecordWitness) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<&Witness> for [u8; 48]

source§

fn from(witness: &Witness) -> [u8; 48]

Converts to this type from the input type.
","From<&Witness>","sp_consensus_subspace::offence::Kind"],["
source§

impl From<&Commitment> for [u8; 48]

source§

fn from(commitment: &Commitment) -> [u8; 48]

Converts to this type from the input type.
","From<&Commitment>","sp_consensus_subspace::offence::Kind"],["
source§

impl From<Commitment> for [u8; 48]

source§

fn from(commitment: Commitment) -> [u8; 48]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl From<Randomness> for [u8; 32]

source§

fn from(original: Randomness) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"],["
source§

impl<T, const N: usize> [T; N]

1.55.0 · source

pub fn map<F, U>(self, f: F) -> [U; N]
where\n F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element\nin order.

\n

If you don’t necessarily need a new fixed-size array, consider using\nIterator::map instead.

\n
Note on performance and stack usage
\n

Unfortunately, usages of this method are currently not always optimized\nas well as they could be. This mainly concerns large arrays, as mapping\nover small arrays seem to be optimized just fine. Also note that in\ndebug mode (i.e. without any optimizations), this method can use a lot\nof stack space (a few times the size of the array or more).

\n

Therefore, in performance-critical code, try to avoid using this method\non large arrays or check the emitted code. Also try to avoid chained\nmaps (e.g. arr.map(...).map(...)).

\n

In many cases, you can instead use Iterator::map by calling .iter()\nor .into_iter() on your array. [T; N]::map is only necessary if you\nreally need a new array of the same size as the result. Rust’s lazy\niterators tend to get optimized very well.

\n
Examples
\n
let x = [1, 2, 3];\nlet y = x.map(|v| v + 1);\nassert_eq!(y, [2, 3, 4]);\n\nlet x = [1, 2, 3];\nlet mut temp = 0;\nlet y = x.map(|v| { temp += 1; v * temp });\nassert_eq!(y, [1, 4, 9]);\n\nlet x = [\"Ferris\", \"Bueller's\", \"Day\", \"Off\"];\nlet y = x.map(|v| v.len());\nassert_eq!(y, [6, 9, 3, 3]);
\n
source

pub fn try_map<F, R>(\n self,\n f: F\n) -> <<R as Try>::Residual as Residual<[<R as Try>::Output; N]>>::TryType
where\n F: FnMut(T) -> R,\n R: Try,\n <R as Try>::Residual: Residual<[<R as Try>::Output; N]>,

🔬This is a nightly-only experimental API. (array_try_map)

A fallible function f applied to each element on array self in order to\nreturn an array the same size as self or the first error encountered.

\n

The return type of this function depends on the return type of the closure.\nIf you return Result<T, E> from the closure, you’ll get a Result<[T; N], E>.\nIf you return Option<T> from the closure, you’ll get an Option<[T; N]>.

\n
Examples
\n
#![feature(array_try_map)]\nlet a = [\"1\", \"2\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>()).unwrap().map(|v| v + 1);\nassert_eq!(b, [2, 3, 4]);\n\nlet a = [\"1\", \"2a\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>());\nassert!(b.is_err());\n\nuse std::num::NonZeroU32;\nlet z = [1, 2, 0, 3, 4];\nassert_eq!(z.try_map(NonZeroU32::new), None);\nlet a = [1, 2, 3];\nlet b = a.try_map(NonZeroU32::new);\nlet c = b.map(|x| x.map(NonZeroU32::get));\nassert_eq!(c, Some(a));
\n
1.57.0 (const: 1.57.0) · source

pub const fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

\n
1.57.0 · source

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to\n&mut s[..].

\n
source

pub fn each_ref(&self) -> [&T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element and returns an array of references with the same\nsize as self.

\n
Example
\n
#![feature(array_methods)]\n\nlet floats = [3.1, 2.7, -1.0];\nlet float_refs: [&f64; 3] = floats.each_ref();\nassert_eq!(float_refs, [&3.1, &2.7, &-1.0]);
\n

This method is particularly useful if combined with other methods, like\nmap. This way, you can avoid moving the original\narray if its elements are not Copy.

\n\n
#![feature(array_methods)]\n\nlet strings = [\"Ferris\".to_string(), \"♥\".to_string(), \"Rust\".to_string()];\nlet is_ascii = strings.each_ref().map(|s| s.is_ascii());\nassert_eq!(is_ascii, [true, false, true]);\n\n// We can still access the original array: it has not been moved.\nassert_eq!(strings.len(), 3);
\n
source

pub fn each_mut(&mut self) -> [&mut T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element mutably and returns an array of mutable references\nwith the same size as self.

\n
Example
\n
#![feature(array_methods)]\n\nlet mut floats = [3.1, 2.7, -1.0];\nlet float_refs: [&mut f64; 3] = floats.each_mut();\n*float_refs[0] = 0.0;\nassert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);\nassert_eq!(floats, [0.0, 2.7, -1.0]);
\n
source

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

\n

The first will contain all indices from [0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n   let (left, right) = v.split_array_ref::<0>();\n   assert_eq!(left, &[]);\n   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}\n\n{\n    let (left, right) = v.split_array_ref::<2>();\n    assert_eq!(left, &[1, 2]);\n    assert_eq!(right, &[3, 4, 5, 6]);\n}\n\n{\n    let (left, right) = v.split_array_ref::<6>();\n    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n    assert_eq!(right, &[]);\n}
\n
source

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

\n

The first will contain all indices from [0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.split_array_mut::<2>();\nassert_eq!(left, &mut [1, 0][..]);\nassert_eq!(right, &mut [3, 0, 5, 6]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);
\n
source

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

\n

The first will contain all indices from [0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n   let (left, right) = v.rsplit_array_ref::<0>();\n   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n   assert_eq!(right, &[]);\n}\n\n{\n    let (left, right) = v.rsplit_array_ref::<2>();\n    assert_eq!(left, &[1, 2, 3, 4]);\n    assert_eq!(right, &[5, 6]);\n}\n\n{\n    let (left, right) = v.rsplit_array_ref::<6>();\n    assert_eq!(left, &[]);\n    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}
\n
source

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

\n

The first will contain all indices from [0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.rsplit_array_mut::<4>();\nassert_eq!(left, &mut [1, 0]);\nassert_eq!(right, &mut [3, 0, 5, 6][..]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);
\n
",0,"sp_consensus_subspace::offence::Kind"],["
source§

impl<const N: usize> [u8; N]

source

pub const fn as_ascii(&self) -> Option<&[AsciiChar; N]>

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters,\nor returns None if any of the characters is non-ASCII.

\n
Examples
\n
#![feature(ascii_char)]\n#![feature(const_option)]\n\nconst HEX_DIGITS: [std::ascii::Char; 16] =\n    *b\"0123456789abcdef\".as_ascii().unwrap();\n\nassert_eq!(HEX_DIGITS[1].as_str(), \"1\");\nassert_eq!(HEX_DIGITS[10].as_str(), \"a\");
\n
source

pub const unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters,\nwithout checking whether they’re valid.

\n
Safety
\n

Every byte in the array must be in 0..=127, or else this is UB.

\n
",0,"sp_consensus_subspace::offence::Kind"],["
§

impl From<Hash> for [u8; 32]

§

fn from(hash: Hash) -> [u8; 32]

Converts to this type from the input type.
","From","sp_consensus_subspace::offence::Kind"]], +"subspace_core_primitives":[["
1.4.0 · source§

impl<T, const N: usize> Borrow<[T]> for [T; N]

source§

fn borrow(&self) -> &[T]

Immutably borrows from an owned value. Read more
","Borrow<[T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.50.0 · source§

impl<T, I, const N: usize> IndexMut<I> for [T; N]
where\n [T]: IndexMut<I>,

source§

fn index_mut(&mut self, index: I) -> &mut <[T; N] as Index<I>>::Output

Performs the mutable indexing (container[index]) operation. Read more
","IndexMut","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<T, const N: usize> StructuralEq for [T; N]

","StructuralEq","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> Eq for [T; N]
where\n T: Eq,

","Eq","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.53.0 · source§

impl<T, const N: usize> IntoIterator for [T; N]

source§

fn into_iter(self) -> <[T; N] as IntoIterator>::IntoIter

Creates a consuming iterator, that is, one that moves each value out of\nthe array (from start to end). The array cannot be used after calling\nthis unless T implements Copy, so the whole array is copied.

\n

Arrays have special behavior when calling .into_iter() prior to the\n2021 edition – see the array Editions section for more information.

\n
§

type Item = T

The type of the elements being iterated over.
§

type IntoIter = IntoIter<T, N>

Which kind of iterator are we turning this into?
","IntoIterator","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> Ord for [T; N]
where\n T: Ord,

Implements comparison of arrays lexicographically.

\n
source§

fn cmp(&self, other: &[T; N]) -> Ordering

This method returns an Ordering between self and other. Read more
1.21.0 · source§

fn max(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the maximum of two values. Read more
1.21.0 · source§

fn min(self, other: Self) -> Self
where\n Self: Sized,

Compares and returns the minimum of two values. Read more
1.50.0 · source§

fn clamp(self, min: Self, max: Self) -> Self
where\n Self: Sized + PartialOrd,

Restrict a value to a certain interval. Read more
","Ord","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.58.0 · source§

impl<T, const N: usize> Copy for [T; N]
where\n T: Copy,

","Copy","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> AsRef<[T]> for [T; N]

source§

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.
","AsRef<[T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<[B; N]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &[B; N]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &[B; N]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<[B; N]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<&[B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &&[B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &&[B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<&[B]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<&mut [B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &&mut [B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &&mut [B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<&mut [B]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<A, B, const N: usize> PartialEq<[B]> for [A; N]
where\n A: PartialEq<B>,

source§

fn eq(&self, other: &[B]) -> bool

This method tests for self and other values to be equal, and is used\nby ==.
source§

fn ne(&self, other: &[B]) -> bool

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq<[B]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<T, const N: usize> ConstParamTy for [T; N]
where\n T: ConstParamTy,

","ConstParamTy","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.71.0 · source§

impl<T> From<(T,)> for [T; 1]

source§

fn from(tuple: (T,)) -> [T; 1]

Converts to this type from the input type.
","From<(T,)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T)> for [T; 9]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T)) -> [T; 9]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T, T)> for [T; 12]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T, T)) -> [T; 12]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T)> for [T; 6]

source§

fn from(tuple: (T, T, T, T, T, T)) -> [T; 6]

Converts to this type from the input type.
","From<(T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T)> for [T; 7]

source§

fn from(tuple: (T, T, T, T, T, T, T)) -> [T; 7]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T, T)> for [T; 10]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T, T)) -> [T; 10]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
source§

impl<T, const N: usize> From<Simd<T, N>> for [T; N]
where\n LaneCount<N>: SupportedLaneCount,\n T: SimdElement,

source§

fn from(vector: Simd<T, N>) -> [T; N]

Converts to this type from the input type.
","From>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T)> for [T; 5]

source§

fn from(tuple: (T, T, T, T, T)) -> [T; 5]

Converts to this type from the input type.
","From<(T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T)> for [T; 2]

source§

fn from(tuple: (T, T)) -> [T; 2]

Converts to this type from the input type.
","From<(T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T, T, T, T)> for [T; 11]

source§

fn from(tuple: (T, T, T, T, T, T, T, T, T, T, T)) -> [T; 11]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T, T, T, T, T)> for [T; 8]

source§

fn from(tuple: (T, T, T, T, T, T, T, T)) -> [T; 8]

Converts to this type from the input type.
","From<(T, T, T, T, T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T, T)> for [T; 4]

source§

fn from(tuple: (T, T, T, T)) -> [T; 4]

Converts to this type from the input type.
","From<(T, T, T, T)>","subspace_core_primitives::Blake3Hash"],["
1.71.0 · source§

impl<T> From<(T, T, T)> for [T; 3]

source§

fn from(tuple: (T, T, T)) -> [T; 3]

Converts to this type from the input type.
","From<(T, T, T)>","subspace_core_primitives::Blake3Hash"],["
source§

impl<T, const N: usize> StructuralPartialEq for [T; N]

","StructuralPartialEq","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 22]
where\n T: Default,

source§

fn default() -> [T; 22]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 21]
where\n T: Default,

source§

fn default() -> [T; 21]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 31]
where\n T: Default,

source§

fn default() -> [T; 31]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 4]
where\n T: Default,

source§

fn default() -> [T; 4]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 9]
where\n T: Default,

source§

fn default() -> [T; 9]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 2]
where\n T: Default,

source§

fn default() -> [T; 2]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 5]
where\n T: Default,

source§

fn default() -> [T; 5]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 7]
where\n T: Default,

source§

fn default() -> [T; 7]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 11]
where\n T: Default,

source§

fn default() -> [T; 11]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 15]
where\n T: Default,

source§

fn default() -> [T; 15]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 27]
where\n T: Default,

source§

fn default() -> [T; 27]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 1]
where\n T: Default,

source§

fn default() -> [T; 1]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 17]
where\n T: Default,

source§

fn default() -> [T; 17]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 20]
where\n T: Default,

source§

fn default() -> [T; 20]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 19]
where\n T: Default,

source§

fn default() -> [T; 19]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 26]
where\n T: Default,

source§

fn default() -> [T; 26]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 25]
where\n T: Default,

source§

fn default() -> [T; 25]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 24]
where\n T: Default,

source§

fn default() -> [T; 24]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 10]
where\n T: Default,

source§

fn default() -> [T; 10]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 0]

source§

fn default() -> [T; 0]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 14]
where\n T: Default,

source§

fn default() -> [T; 14]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 30]
where\n T: Default,

source§

fn default() -> [T; 30]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 12]
where\n T: Default,

source§

fn default() -> [T; 12]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 32]
where\n T: Default,

source§

fn default() -> [T; 32]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 8]
where\n T: Default,

source§

fn default() -> [T; 8]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 13]
where\n T: Default,

source§

fn default() -> [T; 13]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 18]
where\n T: Default,

source§

fn default() -> [T; 18]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 16]
where\n T: Default,

source§

fn default() -> [T; 16]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 6]
where\n T: Default,

source§

fn default() -> [T; 6]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 28]
where\n T: Default,

source§

fn default() -> [T; 28]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 3]
where\n T: Default,

source§

fn default() -> [T; 3]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 29]
where\n T: Default,

source§

fn default() -> [T; 29]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T> Default for [T; 23]
where\n T: Default,

source§

fn default() -> [T; 23]

Returns the “default value” for a type. Read more
","Default","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.34.0 · source§

impl<T, const N: usize> TryFrom<&[T]> for [T; N]
where\n T: Copy,

Tries to create an array [T; N] by copying from a slice &[T]. Succeeds if\nslice.len() == N.

\n\n
let bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = bytes[1..3].try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));
\n
§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &[T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.
","TryFrom<&[T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.59.0 · source§

impl<T, const N: usize> TryFrom<&mut [T]> for [T; N]
where\n T: Copy,

Tries to create an array [T; N] by copying from a mutable slice &mut [T].\nSucceeds if slice.len() == N.

\n\n
let mut bytes: [u8; 3] = [1, 0, 2];\n\nlet bytes_head: [u8; 2] = <[u8; 2]>::try_from(&mut bytes[0..2]).unwrap();\nassert_eq!(1, u16::from_le_bytes(bytes_head));\n\nlet bytes_tail: [u8; 2] = (&mut bytes[1..3]).try_into().unwrap();\nassert_eq!(512, u16::from_le_bytes(bytes_tail));
\n
§

type Error = TryFromSliceError

The type returned in the event of a conversion error.
source§

fn try_from(slice: &mut [T]) -> Result<[T; N], TryFromSliceError>

Performs the conversion.
","TryFrom<&mut [T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> PartialOrd for [T; N]
where\n T: PartialOrd,

source§

fn partial_cmp(&self, other: &[T; N]) -> Option<Ordering>

This method returns an ordering between self and other values if one exists. Read more
source§

fn lt(&self, other: &[T; N]) -> bool

This method tests less than (for self and other) and is used by the < operator. Read more
source§

fn le(&self, other: &[T; N]) -> bool

This method tests less than or equal to (for self and other) and is used by the <=\noperator. Read more
source§

fn ge(&self, other: &[T; N]) -> bool

This method tests greater than or equal to (for self and other) and is used by the >=\noperator. Read more
source§

fn gt(&self, other: &[T; N]) -> bool

This method tests greater than (for self and other) and is used by the > operator. Read more
","PartialOrd","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> Hash for [T; N]
where\n T: Hash,

The hash of an array is the same as that of the corresponding slice,\nas required by the Borrow implementation.

\n\n
use std::hash::BuildHasher;\n\nlet b = std::hash::RandomState::new();\nlet a: [u8; 3] = [0xa8, 0x3c, 0x09];\nlet s: &[u8] = &[0xa8, 0x3c, 0x09];\nassert_eq!(b.hash_one(a), b.hash_one(s));
\n
source§

fn hash<H>(&self, state: &mut H)
where\n H: Hasher,

Feeds this value into the given Hasher. Read more
1.3.0 · source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where\n H: Hasher,\n Self: Sized,

Feeds a slice of this type into the given Hasher. Read more
","Hash","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.4.0 · source§

impl<T, const N: usize> BorrowMut<[T]> for [T; N]

source§

fn borrow_mut(&mut self) -> &mut [T]

Mutably borrows from an owned value. Read more
","BorrowMut<[T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.58.0 · source§

impl<T, const N: usize> Clone for [T; N]
where\n T: Clone,

source§

fn clone(&self) -> [T; N]

Returns a copy of the value. Read more
source§

fn clone_from(&mut self, other: &[T; N])

Performs copy-assignment from source. Read more
","Clone","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.50.0 · source§

impl<T, I, const N: usize> Index<I> for [T; N]
where\n [T]: Index<I>,

§

type Output = <[T] as Index<I>>::Output

The returned type after indexing.
source§

fn index(&self, index: I) -> &<[T; N] as Index<I>>::Output

Performs the indexing (container[index]) operation. Read more
","Index","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> Debug for [T; N]
where\n T: Debug,

source§

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

Formats the value using the given formatter. Read more
","Debug","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.0.0 · source§

impl<T, const N: usize> AsMut<[T]> for [T; N]

source§

fn as_mut(&mut self) -> &mut [T]

Converts this type into a mutable reference of the (usually inferred) input type.
","AsMut<[T]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.51.0 · source§

impl<T, const N: usize> SlicePattern for [T; N]

§

type Item = T

🔬This is a nightly-only experimental API. (slice_pattern)
The element type of the slice being matched on.
source§

fn as_slice(&self) -> &[<[T; N] as SlicePattern>::Item]

🔬This is a nightly-only experimental API. (slice_pattern)
Currently, the consumers of SlicePattern need a slice.
","SlicePattern","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
1.48.0 · source§

impl<T, A, const N: usize> TryFrom<Vec<T, A>> for [T; N]
where\n A: Allocator,

source§

fn try_from(vec: Vec<T, A>) -> Result<[T; N], Vec<T, A>>

Gets the entire contents of the Vec<T> as an array,\nif its size exactly matches that of the requested array.

\n
Examples
\n
assert_eq!(vec![1, 2, 3].try_into(), Ok([1, 2, 3]));\nassert_eq!(<Vec<i32>>::new().try_into(), Ok([]));
\n

If the length doesn’t match, the input comes back in Err:

\n\n
let r: Result<[i32; 4], _> = (0..10).collect::<Vec<_>>().try_into();\nassert_eq!(r, Err(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9]));
\n

If you’re fine with just getting a prefix of the Vec<T>,\nyou can call .truncate(N) first.

\n\n
let mut v = String::from(\"hello world\").into_bytes();\nv.sort();\nv.truncate(2);\nlet [a, b]: [_; 2] = v.try_into().unwrap();\nassert_eq!(a, b' ');\nassert_eq!(b, b'd');
\n
§

type Error = Vec<T, A>

The type returned in the event of a conversion error.
","TryFrom>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, const N: usize> Encode for [T; N]
where\n T: Encode,

§

fn size_hint(&self) -> usize

If possible give a hint of expected size of the encoding. Read more
§

fn encode_to<W>(&self, dest: &mut W)
where\n W: Output + ?Sized,

Convert self to a slice and append it to the destination.
§

fn encode(&self) -> Vec<u8> ⓘ

Convert self to an owned vector.
§

fn using_encoded<R, F>(&self, f: F) -> R
where\n F: FnOnce(&[u8]) -> R,

Convert self to a slice and then invoke the given closure with it.
§

fn encoded_size(&self) -> usize

Calculates the encoded size. Read more
","Encode","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, const N: usize> MaxEncodedLen for [T; N]
where\n T: MaxEncodedLen,

§

fn max_encoded_len() -> usize

Upper bound, in bytes, of the maximum encoded size of this item.
","MaxEncodedLen","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, U, const N: usize> EncodeLike<[U; N]> for [T; N]
where\n T: EncodeLike<U>,\n U: Encode,

","EncodeLike<[U; N]>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, const N: usize> ConstEncodedLen for [T; N]
where\n T: ConstEncodedLen,

","ConstEncodedLen","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, const N: usize> Decode for [T; N]
where\n T: Decode,

§

fn decode<I>(input: &mut I) -> Result<[T; N], Error>
where\n I: Input,

Attempt to deserialise the value from input.
§

fn decode_into<I>(\n input: &mut I,\n dst: &mut MaybeUninit<[T; N]>\n) -> Result<DecodeFinished, Error>
where\n I: Input,

Attempt to deserialize the value from input into a pre-allocated piece of memory. Read more
§

fn skip<I>(input: &mut I) -> Result<(), Error>
where\n I: Input,

Attempt to skip the encoded value from input. Read more
§

fn encoded_fixed_size() -> Option<usize>

Returns the fixed encoded size of the type. Read more
","Decode","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<const N: usize> FromByteSlice for [u8; N]

§

fn from_byte_slice<T>(slice: &T) -> Result<&[[u8; N]], Error>
where\n T: AsRef<[u8]> + ?Sized,

Convert from an immutable byte slice to a immutable slice of a fundamental, built-in\nnumeric type
§

fn from_mut_byte_slice<T>(slice: &mut T) -> Result<&mut [[u8; N]], Error>
where\n T: AsMut<[u8]> + ?Sized,

Convert from an mutable byte slice to a mutable slice of a fundamental, built-in numeric\ntype
","FromByteSlice","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<const N: usize> ToMutByteSlice for [u8; N]

§

fn to_mut_byte_slice<T>(slice: &mut T) -> &mut [u8] ⓘ
where\n T: AsMut<[[u8; N]]> + ?Sized,

Convert from a mutable slice of a fundamental, built-in numeric type to a mutable byte\nslice
","ToMutByteSlice","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<const N: usize> ToByteSlice for [u8; N]

§

fn to_byte_slice<T>(slice: &T) -> &[u8] ⓘ
where\n T: AsRef<[[u8; N]]> + ?Sized,

Convert from an immutable slice of a fundamental, built-in numeric type to an immutable\nbyte slice
","ToByteSlice","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 1]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 1], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 28]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 28], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 19]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 19], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 31]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 31], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 26]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 26], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 32]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 32], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 16]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 16], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 14]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 14], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 0]

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 0], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 4]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 4], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 17]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 17], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 12]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 12], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 13]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 13], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 27]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 27], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 23]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 23], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 20]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 20], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 11]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 11], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 2]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 2], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 6]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 6], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 25]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 25], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 15]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 15], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 7]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 7], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 21]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 21], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 24]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 24], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 10]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 10], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 29]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 29], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 9]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 9], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 22]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 22], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 18]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 18], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 8]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 8], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 30]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 30], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 5]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 5], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<'de, T> Deserialize<'de> for [T; 3]
where\n T: Deserialize<'de>,

source§

fn deserialize<D>(\n deserializer: D\n) -> Result<[T; 3], <D as Deserializer<'de>>::Error>
where\n D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer. Read more
","Deserialize<'de>","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 10]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 30]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 28]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 12]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 32]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<T> Serialize for [T; 18]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 11]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 0]

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 1]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 15]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 6]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 26]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 17]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 9]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 8]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 16]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 22]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 14]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 4]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 23]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 5]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 29]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 27]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 3]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 24]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 20]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 25]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 31]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 2]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 21]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 7]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 19]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
source§

impl<T> Serialize for [T; 13]
where\n T: Serialize,

source§

fn serialize<S>(\n &self,\n serializer: S\n) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>
where\n S: Serializer,

Serialize this value into the given Serde serializer. Read more
","Serialize","subspace_core_primitives::Blake3Hash"],["
§

impl<Z, const N: usize> Zeroize for [Z; N]
where\n Z: Zeroize,

Impl [Zeroize] on arrays of types that impl [Zeroize].

\n
§

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the\nzeroization operation is not “optimized away” by the compiler.
","Zeroize","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<Z, const N: usize> ZeroizeOnDrop for [Z; N]
where\n Z: ZeroizeOnDrop,

Impl [ZeroizeOnDrop] on arrays of types that impl [ZeroizeOnDrop].

\n
","ZeroizeOnDrop","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>> for [T; 56]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B0>>\n) -> [T; 56]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>> for [T; 35]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>>\n) -> [T; 35]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>> for [T; 57]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>, B1>>\n) -> [T; 57]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>> for [T; 37]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>>\n) -> [T; 37]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>> for [T; 53]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B1>>\n) -> [T; 53]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>> for [T; 50]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>>\n) -> [T; 50]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>> for [T; 43]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B1>>\n) -> [T; 43]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>>> for [T; 22]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>>\n) -> [T; 22]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>> for [T; 7]

§

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B1>>) -> [T; 7]

Converts to this type from the input type.
","From, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>>> for [T; 17]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>>\n) -> [T; 17]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>> for [T; 48]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>>\n) -> [T; 48]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UTerm, B1>, B1>>> for [T; 3]

§

fn from(sel: GenericArray<T, UInt<UInt<UTerm, B1>, B1>>) -> [T; 3]

Converts to this type from the input type.
","From, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>>> for [T; 28]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B0>>\n) -> [T; 28]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 300]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>\n) -> [T; 300]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>>> for [T; 23]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>>\n) -> [T; 23]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 1000]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>\n) -> [T; 1000]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>>> for [T; 18]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>>\n) -> [T; 18]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>> for [T; 44]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B0>>\n) -> [T; 44]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 36]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B0>, B0>>\n) -> [T; 36]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>> for [T; 8]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>\n) -> [T; 8]

Converts to this type from the input type.
","From, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>> for [T; 5]

§

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B1>>) -> [T; 5]

Converts to this type from the input type.
","From, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>>> for [T; 30]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>>\n) -> [T; 30]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>>> for [T; 31]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>>\n) -> [T; 31]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>> for [T; 100]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>>\n) -> [T; 100]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>>> for [T; 29]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>>\n) -> [T; 29]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>>> for [T; 24]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>>\n) -> [T; 24]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>> for [T; 12]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>\n) -> [T; 12]

Converts to this type from the input type.
","From, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 64]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 64]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 1024]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 1024]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>> for [T; 39]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>>\n) -> [T; 39]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>> for [T; 16]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>\n) -> [T; 16]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>> for [T; 40]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>>\n) -> [T; 40]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 400]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>\n) -> [T; 400]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>> for [T; 90]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>, B0>>\n) -> [T; 90]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>> for [T; 9]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>\n) -> [T; 9]

Converts to this type from the input type.
","From, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>> for [T; 200]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>>\n) -> [T; 200]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>> for [T; 33]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B1>>\n) -> [T; 33]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>>> for [T; 13]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>>\n) -> [T; 13]

Converts to this type from the input type.
","From, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>> for [T; 51]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>, B1>>\n) -> [T; 51]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>>> for [T; 26]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>>\n) -> [T; 26]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>> for [T; 4]

§

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B0>, B0>>) -> [T; 4]

Converts to this type from the input type.
","From, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>> for [T; 63]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B1>>\n) -> [T; 63]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>> for [T; 59]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B1>>\n) -> [T; 59]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 52]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B0>, B0>>\n) -> [T; 52]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>> for [T; 55]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B1>>\n) -> [T; 55]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>> for [T; 32]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 32]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T> From<GenericArray<T, UInt<UTerm, B1>>> for [T; 1]

§

fn from(sel: GenericArray<T, UInt<UTerm, B1>>) -> [T; 1]

Converts to this type from the input type.
","From>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>> for [T; 38]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B0>>\n) -> [T; 38]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>> for [T; 45]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B0>, B1>>\n) -> [T; 45]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>> for [T; 500]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>\n) -> [T; 500]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 128]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 128]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>> for [T; 54]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>, B0>>\n) -> [T; 54]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>> for [T; 46]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B0>>\n) -> [T; 46]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>> for [T; 25]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>\n) -> [T; 25]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>> for [T; 34]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B0>>\n) -> [T; 34]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>> for [T; 6]

§

fn from(sel: GenericArray<T, UInt<UInt<UInt<UTerm, B1>, B1>, B0>>) -> [T; 6]

Converts to this type from the input type.
","From, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UTerm, B1>, B0>>> for [T; 2]

§

fn from(sel: GenericArray<T, UInt<UInt<UTerm, B1>, B0>>) -> [T; 2]

Converts to this type from the input type.
","From, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>> for [T; 42]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>, B0>>\n) -> [T; 42]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>> for [T; 80]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>>\n) -> [T; 80]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>> for [T; 60]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>>\n) -> [T; 60]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 256]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 256]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>> for [T; 61]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B1>>\n) -> [T; 61]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>> for [T; 47]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>, B1>, B1>>\n) -> [T; 47]

Converts to this type from the input type.
","From, B0>, B1>, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>> for [T; 49]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B1>>\n) -> [T; 49]

Converts to this type from the input type.
","From, B1>, B0>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>> for [T; 10]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>\n) -> [T; 10]

Converts to this type from the input type.
","From, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>> for [T; 62]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>>\n) -> [T; 62]

Converts to this type from the input type.
","From, B1>, B1>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>> for [T; 70]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B1>, B1>, B0>>\n) -> [T; 70]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>> for [T; 41]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B1>>\n) -> [T; 41]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>>> for [T; 11]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B1>>\n) -> [T; 11]

Converts to this type from the input type.
","From, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>> for [T; 512]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>\n) -> [T; 512]

Converts to this type from the input type.
","From, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>>> for [T; 19]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>>\n) -> [T; 19]

Converts to this type from the input type.
","From, B0>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>> for [T; 20]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>\n) -> [T; 20]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>>> for [T; 21]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B1>>\n) -> [T; 21]

Converts to this type from the input type.
","From, B0>, B1>, B0>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>> for [T; 58]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>, B1>, B0>>\n) -> [T; 58]

Converts to this type from the input type.
","From, B1>, B1>, B0>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>> for [T; 27]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>\n) -> [T; 27]

Converts to this type from the input type.
","From, B1>, B0>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>> for [T; 15]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>\n) -> [T; 15]

Converts to this type from the input type.
","From, B1>, B1>, B1>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T> From<GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>> for [T; 14]

§

fn from(\n sel: GenericArray<T, UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B0>>\n) -> [T; 14]

Converts to this type from the input type.
","From, B1>, B1>, B0>>>","subspace_core_primitives::Blake3Hash"],["
§

impl<T, const N: usize> Array for [T; N]

§

type Item = T

The type of the array’s elements.
§

fn size() -> usize

Returns the number of items the array can hold.
","Array","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl<T, const N: usize> IntoParallelIterator for [T; N]
where\n T: Send,

§

type Item = T

The type of item that the parallel iterator will produce.
§

type Iter = IntoIter<T, N>

The parallel iterator type that will be created.
§

fn into_par_iter(self) -> <[T; N] as IntoParallelIterator>::Iter

Converts self into a parallel iterator. Read more
","IntoParallelIterator","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl FromHex for [u8; 77]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 77], <[u8; 77] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 27]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 27], <[u8; 27] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 4294967296]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 4294967296], <[u8; 4294967296] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 111]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 111], <[u8; 111] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 87]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 87], <[u8; 87] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 46]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 46], <[u8; 46] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 108]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 108], <[u8; 108] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 66]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 66], <[u8; 66] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 99]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 99], <[u8; 99] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 73]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 73], <[u8; 73] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 3]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 3], <[u8; 3] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 123]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 123], <[u8; 123] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 20]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 20], <[u8; 20] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 84]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 84], <[u8; 84] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 268435456]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 268435456], <[u8; 268435456] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 256]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 256], <[u8; 256] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 2]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 2], <[u8; 2] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 38]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 38], <[u8; 38] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 62]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 62], <[u8; 62] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 89]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 89], <[u8; 89] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 384]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 384], <[u8; 384] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 7]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 7], <[u8; 7] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 524288]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 524288], <[u8; 524288] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 125]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 125], <[u8; 125] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 81]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 81], <[u8; 81] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 12]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 12], <[u8; 12] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 101]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 101], <[u8; 101] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 67108864]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 67108864], <[u8; 67108864] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 96]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 96], <[u8; 96] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 69]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 69], <[u8; 69] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 91]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 91], <[u8; 91] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 78]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 78], <[u8; 78] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 116]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 116], <[u8; 116] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 65]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 65], <[u8; 65] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 29]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 29], <[u8; 29] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 53]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 53], <[u8; 53] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 21]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 21], <[u8; 21] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 128]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 128], <[u8; 128] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 51]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 51], <[u8; 51] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 8]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 8], <[u8; 8] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 11]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 11], <[u8; 11] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 67]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 67], <[u8; 67] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 6]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 6], <[u8; 6] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 47]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 47], <[u8; 47] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 192]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 192], <[u8; 192] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 22]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 22], <[u8; 22] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 39]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 39], <[u8; 39] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 262144]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 262144], <[u8; 262144] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 42]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 42], <[u8; 42] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 48]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 48], <[u8; 48] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 71]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 71], <[u8; 71] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 768]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 768], <[u8; 768] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 32]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 32], <[u8; 32] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl FromHex for [u8; 44]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 44], <[u8; 44] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 115]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 115], <[u8; 115] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 9]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 9], <[u8; 9] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 15]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 15], <[u8; 15] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 106]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 106], <[u8; 106] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 64]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 64], <[u8; 64] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 109]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 109], <[u8; 109] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 117]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 117], <[u8; 117] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 93]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 93], <[u8; 93] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 2147483648]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 2147483648], <[u8; 2147483648] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 107]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 107], <[u8; 107] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 16777216]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 16777216], <[u8; 16777216] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 2048]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 2048], <[u8; 2048] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 36]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 36], <[u8; 36] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 131072]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 131072], <[u8; 131072] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 1073741824]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 1073741824], <[u8; 1073741824] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 1]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 1], <[u8; 1] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 40]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 40], <[u8; 40] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 33]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 33], <[u8; 33] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 37]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 37], <[u8; 37] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 61]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 61], <[u8; 61] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 26]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 26], <[u8; 26] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 104]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 104], <[u8; 104] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 100]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 100], <[u8; 100] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 113]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 113], <[u8; 113] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 83]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 83], <[u8; 83] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 1024]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 1024], <[u8; 1024] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 88]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 88], <[u8; 88] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 126]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 126], <[u8; 126] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 68]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 68], <[u8; 68] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 5]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 5], <[u8; 5] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 41]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 41], <[u8; 41] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 25]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 25], <[u8; 25] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 85]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 85], <[u8; 85] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 102]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 102], <[u8; 102] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 1048576]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 1048576], <[u8; 1048576] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 200]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 200], <[u8; 200] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 30]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 30], <[u8; 30] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 90]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 90], <[u8; 90] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 70]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 70], <[u8; 70] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 72]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 72], <[u8; 72] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 127]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 127], <[u8; 127] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 134217728]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 134217728], <[u8; 134217728] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 58]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 58], <[u8; 58] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 92]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 92], <[u8; 92] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 105]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 105], <[u8; 105] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 16384]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 16384], <[u8; 16384] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 79]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 79], <[u8; 79] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 32768]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 32768], <[u8; 32768] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 121]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 121], <[u8; 121] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 224]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 224], <[u8; 224] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 160]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 160], <[u8; 160] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 80]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 80], <[u8; 80] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 2097152]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 2097152], <[u8; 2097152] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 23]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 23], <[u8; 23] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 512]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 512], <[u8; 512] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 76]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 76], <[u8; 76] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 4]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 4], <[u8; 4] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 31]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 31], <[u8; 31] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 16]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 16], <[u8; 16] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 35]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 35], <[u8; 35] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 98]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 98], <[u8; 98] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 97]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 97], <[u8; 97] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 94]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 94], <[u8; 94] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 63]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 63], <[u8; 63] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 65536]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 65536], <[u8; 65536] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 49]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 49], <[u8; 49] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 50]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 50], <[u8; 50] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 119]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 119], <[u8; 119] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 52]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 52], <[u8; 52] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 8192]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 8192], <[u8; 8192] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 74]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 74], <[u8; 74] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 118]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 118], <[u8; 118] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 112]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 112], <[u8; 112] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 34]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 34], <[u8; 34] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 75]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 75], <[u8; 75] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 122]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 122], <[u8; 122] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 43]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 43], <[u8; 43] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 17]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 17], <[u8; 17] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 28]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 28], <[u8; 28] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 536870912]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 536870912], <[u8; 536870912] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 60]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 60], <[u8; 60] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 124]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 124], <[u8; 124] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 13]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 13], <[u8; 13] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 14]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 14], <[u8; 14] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 114]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 114], <[u8; 114] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 95]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 95], <[u8; 95] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 55]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 55], <[u8; 55] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 45]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 45], <[u8; 45] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 57]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 57], <[u8; 57] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 18]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 18], <[u8; 18] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 24]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 24], <[u8; 24] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 59]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 59], <[u8; 59] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 120]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 120], <[u8; 120] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 103]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 103], <[u8; 103] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 19]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 19], <[u8; 19] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 8388608]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 8388608], <[u8; 8388608] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 4096]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 4096], <[u8; 4096] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 86]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 86], <[u8; 86] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 54]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 54], <[u8; 54] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 82]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 82], <[u8; 82] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 110]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 110], <[u8; 110] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 56]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 56], <[u8; 56] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 4194304]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 4194304], <[u8; 4194304] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 33554432]

§

type Error = FromHexError

source§

fn from_hex<T>(\n hex: T\n) -> Result<[u8; 33554432], <[u8; 33554432] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
source§

impl FromHex for [u8; 10]

§

type Error = FromHexError

source§

fn from_hex<T>(hex: T) -> Result<[u8; 10], <[u8; 10] as FromHex>::Error>
where\n T: AsRef<[u8]>,

Creates an instance of type Self from the given hex string, or fails\nwith a custom error type. Read more
","FromHex","subspace_core_primitives::Blake3Hash"],["
§

impl<T, const N: usize> TypeInfo for [T; N]
where\n T: TypeInfo + 'static,

§

type Identity = [T; N]

The type identifying for which type info is provided. Read more
§

fn type_info() -> Type

Returns the static type identifier for Self.
","TypeInfo","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
§

impl From<Hash> for [u8; 32]

§

fn from(hash: Hash) -> [u8; 32]

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<&Scalar> for [u8; 32]

source§

fn from(value: &Scalar) -> Self

Converts to this type from the input type.
","From<&Scalar>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<T, const N: usize> [T; N]

1.55.0 · source

pub fn map<F, U>(self, f: F) -> [U; N]
where\n F: FnMut(T) -> U,

Returns an array of the same size as self, with function f applied to each element\nin order.

\n

If you don’t necessarily need a new fixed-size array, consider using\nIterator::map instead.

\n
Note on performance and stack usage
\n

Unfortunately, usages of this method are currently not always optimized\nas well as they could be. This mainly concerns large arrays, as mapping\nover small arrays seem to be optimized just fine. Also note that in\ndebug mode (i.e. without any optimizations), this method can use a lot\nof stack space (a few times the size of the array or more).

\n

Therefore, in performance-critical code, try to avoid using this method\non large arrays or check the emitted code. Also try to avoid chained\nmaps (e.g. arr.map(...).map(...)).

\n

In many cases, you can instead use Iterator::map by calling .iter()\nor .into_iter() on your array. [T; N]::map is only necessary if you\nreally need a new array of the same size as the result. Rust’s lazy\niterators tend to get optimized very well.

\n
Examples
\n
let x = [1, 2, 3];\nlet y = x.map(|v| v + 1);\nassert_eq!(y, [2, 3, 4]);\n\nlet x = [1, 2, 3];\nlet mut temp = 0;\nlet y = x.map(|v| { temp += 1; v * temp });\nassert_eq!(y, [1, 4, 9]);\n\nlet x = [\"Ferris\", \"Bueller's\", \"Day\", \"Off\"];\nlet y = x.map(|v| v.len());\nassert_eq!(y, [6, 9, 3, 3]);
\n
source

pub fn try_map<F, R>(\n self,\n f: F\n) -> <<R as Try>::Residual as Residual<[<R as Try>::Output; N]>>::TryType
where\n F: FnMut(T) -> R,\n R: Try,\n <R as Try>::Residual: Residual<[<R as Try>::Output; N]>,

🔬This is a nightly-only experimental API. (array_try_map)

A fallible function f applied to each element on array self in order to\nreturn an array the same size as self or the first error encountered.

\n

The return type of this function depends on the return type of the closure.\nIf you return Result<T, E> from the closure, you’ll get a Result<[T; N], E>.\nIf you return Option<T> from the closure, you’ll get an Option<[T; N]>.

\n
Examples
\n
#![feature(array_try_map)]\nlet a = [\"1\", \"2\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>()).unwrap().map(|v| v + 1);\nassert_eq!(b, [2, 3, 4]);\n\nlet a = [\"1\", \"2a\", \"3\"];\nlet b = a.try_map(|v| v.parse::<u32>());\nassert!(b.is_err());\n\nuse std::num::NonZeroU32;\nlet z = [1, 2, 0, 3, 4];\nassert_eq!(z.try_map(NonZeroU32::new), None);\nlet a = [1, 2, 3];\nlet b = a.try_map(NonZeroU32::new);\nlet c = b.map(|x| x.map(NonZeroU32::get));\nassert_eq!(c, Some(a));
\n
1.57.0 (const: 1.57.0) · source

pub const fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

\n
1.57.0 · source

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to\n&mut s[..].

\n
source

pub fn each_ref(&self) -> [&T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element and returns an array of references with the same\nsize as self.

\n
Example
\n
#![feature(array_methods)]\n\nlet floats = [3.1, 2.7, -1.0];\nlet float_refs: [&f64; 3] = floats.each_ref();\nassert_eq!(float_refs, [&3.1, &2.7, &-1.0]);
\n

This method is particularly useful if combined with other methods, like\nmap. This way, you can avoid moving the original\narray if its elements are not Copy.

\n\n
#![feature(array_methods)]\n\nlet strings = [\"Ferris\".to_string(), \"♥\".to_string(), \"Rust\".to_string()];\nlet is_ascii = strings.each_ref().map(|s| s.is_ascii());\nassert_eq!(is_ascii, [true, false, true]);\n\n// We can still access the original array: it has not been moved.\nassert_eq!(strings.len(), 3);
\n
source

pub fn each_mut(&mut self) -> [&mut T; N]

🔬This is a nightly-only experimental API. (array_methods)

Borrows each element mutably and returns an array of mutable references\nwith the same size as self.

\n
Example
\n
#![feature(array_methods)]\n\nlet mut floats = [3.1, 2.7, -1.0];\nlet float_refs: [&mut f64; 3] = floats.each_mut();\n*float_refs[0] = 0.0;\nassert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);\nassert_eq!(floats, [0.0, 2.7, -1.0]);
\n
source

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

\n

The first will contain all indices from [0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n   let (left, right) = v.split_array_ref::<0>();\n   assert_eq!(left, &[]);\n   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}\n\n{\n    let (left, right) = v.split_array_ref::<2>();\n    assert_eq!(left, &[1, 2]);\n    assert_eq!(right, &[3, 4, 5, 6]);\n}\n\n{\n    let (left, right) = v.split_array_ref::<6>();\n    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n    assert_eq!(right, &[]);\n}
\n
source

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

\n

The first will contain all indices from [0, M) (excluding\nthe index M itself) and the second will contain all\nindices from [M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.split_array_mut::<2>();\nassert_eq!(left, &mut [1, 0][..]);\nassert_eq!(right, &mut [3, 0, 5, 6]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);
\n
source

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

\n

The first will contain all indices from [0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet v = [1, 2, 3, 4, 5, 6];\n\n{\n   let (left, right) = v.rsplit_array_ref::<0>();\n   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);\n   assert_eq!(right, &[]);\n}\n\n{\n    let (left, right) = v.rsplit_array_ref::<2>();\n    assert_eq!(left, &[1, 2, 3, 4]);\n    assert_eq!(right, &[5, 6]);\n}\n\n{\n    let (left, right) = v.rsplit_array_ref::<6>();\n    assert_eq!(left, &[]);\n    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);\n}
\n
source

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

\n

The first will contain all indices from [0, N - M) (excluding\nthe index N - M itself) and the second will contain all\nindices from [N - M, N) (excluding the index N itself).

\n
Panics
\n

Panics if M > N.

\n
Examples
\n
#![feature(split_array)]\n\nlet mut v = [1, 0, 3, 0, 5, 6];\nlet (left, right) = v.rsplit_array_mut::<4>();\nassert_eq!(left, &mut [1, 0]);\nassert_eq!(right, &mut [3, 0, 5, 6][..]);\nleft[1] = 2;\nright[1] = 4;\nassert_eq!(v, [1, 2, 3, 4, 5, 6]);
\n
",0,"subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl<const N: usize> [u8; N]

source

pub const fn as_ascii(&self) -> Option<&[AsciiChar; N]>

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters,\nor returns None if any of the characters is non-ASCII.

\n
Examples
\n
#![feature(ascii_char)]\n#![feature(const_option)]\n\nconst HEX_DIGITS: [std::ascii::Char; 16] =\n    *b\"0123456789abcdef\".as_ascii().unwrap();\n\nassert_eq!(HEX_DIGITS[1].as_str(), \"1\");\nassert_eq!(HEX_DIGITS[10].as_str(), \"a\");
\n
source

pub const unsafe fn as_ascii_unchecked(&self) -> &[AsciiChar; N]

🔬This is a nightly-only experimental API. (ascii_char)

Converts this array of bytes into a array of ASCII characters,\nwithout checking whether they’re valid.

\n
Safety
\n

Every byte in the array must be in 0..=127, or else this is UB.

\n
",0,"subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<SegmentCommitment> for [u8; 48]

source§

fn from(original: SegmentCommitment) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<Witness> for [u8; 48]

source§

fn from(witness: Witness) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<RecordCommitment> for [u8; 48]

source§

fn from(original: RecordCommitment) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<PublicKey> for [u8; 32]

source§

fn from(original: PublicKey) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<Scalar> for [u8; 32]

source§

fn from(value: Scalar) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<RewardSignature> for [u8; 64]

source§

fn from(original: RewardSignature) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<PosSeed> for [u8; 32]

source§

fn from(value: PosSeed) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<PosProof> for [u8; 160]

source§

fn from(value: PosProof) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<ChunkWitness> for [u8; 48]

source§

fn from(original: ChunkWitness) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<RecordWitness> for [u8; 48]

source§

fn from(original: RecordWitness) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<&Witness> for [u8; 48]

source§

fn from(witness: &Witness) -> Self

Converts to this type from the input type.
","From<&Witness>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<&Commitment> for [u8; 48]

source§

fn from(commitment: &Commitment) -> Self

Converts to this type from the input type.
","From<&Commitment>","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<Commitment> for [u8; 48]

source§

fn from(commitment: Commitment) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"],["
source§

impl From<Randomness> for [u8; 32]

source§

fn from(original: Randomness) -> Self

Converts to this type from the input type.
","From","subspace_core_primitives::Blake3Hash","subspace_core_primitives::BlockHash"]] };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})() \ No newline at end of file