diff --git a/domain_runtime_primitives/trait.DomainCoreApi.html b/domain_runtime_primitives/trait.DomainCoreApi.html index 195b6857f4..7677099ae2 100644 --- a/domain_runtime_primitives/trait.DomainCoreApi.html +++ b/domain_runtime_primitives/trait.DomainCoreApi.html @@ -35,7 +35,7 @@ fn construct_timestamp_extrinsic( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, - moment: Moment + moment: Moment ) -> Result<Block::Extrinsic, ApiError> { ... } fn construct_consensus_chain_byte_fee_extrinsic( &self, @@ -115,7 +115,7 @@
source

fn construct_timestamp_extrinsic( &self, __runtime_api_at_param__: <Block as BlockT>::Hash, - moment: Moment + moment: Moment ) -> Result<Block::Extrinsic, ApiError>

Returns an encoded extrinsic to set timestamp.

source

fn construct_consensus_chain_byte_fee_extrinsic( &self, diff --git a/domain_test_service/domain/struct.DomainNodeBuilder.html b/domain_test_service/domain/struct.DomainNodeBuilder.html index 65a2cf261c..83eef5b8ca 100644 --- a/domain_test_service/domain/struct.DomainNodeBuilder.html +++ b/domain_test_service/domain/struct.DomainNodeBuilder.html @@ -14,7 +14,7 @@ self, role: Role, domain_id: DomainId, - mock_consensus_node: &mut MockConsensusNode + mock_consensus_node: &mut MockConsensusNode ) -> EvmDomainNode

Build a evm domain node

Auto Trait Implementations§

§

impl !RefUnwindSafe for DomainNodeBuilder

§

impl Send for DomainNodeBuilder

§

impl Sync for DomainNodeBuilder

§

impl Unpin for DomainNodeBuilder

§

impl !UnwindSafe for DomainNodeBuilder

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/domain_test_service/domain/type.DomainOperator.html b/domain_test_service/domain/type.DomainOperator.html index 76850bb5f0..5c89810342 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.

+

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 1bf306735a..b7948f68f5 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 a0bb3ed0c0..397c9c0d51 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 80fddc8140..a59f9a1aaf 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_rewards/trait.Config.html b/pallet_rewards/trait.Config.html index 4268e82e73..b8c03ae43c 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/search-index.js b/search-index.js index d6d636be46..834e47fca0 100644 --- a/search-index.js +++ b/search-index.js @@ -45,9 +45,9 @@ var searchIndex = new Map(JSON.parse('[\ ["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":"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",{"doc":"subspace-farmer library implementation overview","t":"FSEFENNNNNNNNNNNNNNNNNNNNNNNNNNNENNCNNNCNCNNNCNNNNNNCNNNNNNNNNNCNNIKKMMMMMMMMMMMFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHPPGPPPPPPPPPPPPPPPPPPPPPPPPPPPEPPPPPPPPPPPPTPPPPPTPPPGPPGGGFGGGFFGGPPPPPPPPNONNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNOOOCONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONONNNONNNNCNOCNNNNOONNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPFPFPPPGGPPPPFFPFGPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONOCOOOONNNNNONNOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOFNNNNNNNNNNNNNNNNPPFGPFPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOFNNNNNNNNNNNNNNNNNNFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNFFHNNNNNNNHNNNNNNNCNNNNNNNNNHCNNHCHNHCHNHNNNNNNNNNNNNFNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNNPPPPPGNNNNNNNNNNHNNNNNN","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","regroup","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"],[977,"subspace_farmer::utils::farmer_piece_getter"],[993,"subspace_farmer::utils::piece_validator"],[1012,"subspace_farmer::utils::readers_and_pieces"],[1033,"subspace_farmer::utils::ss58"],[1056,"subspace_core_primitives::segments"],[1057,"core::future::future"],[1058,"alloc::boxed"],[1059,"core::pin"],[1060,"core::result"],[1061,"std::path"],[1062,"core::convert"],[1063,"core::fmt"],[1064,"core::fmt"],[1065,"core::option"],[1066,"subspace_core_primitives::pieces"],[1067,"schnorrkel::keys"],[1068,"schnorrkel::keys"],[1069,"schnorrkel::sign"],[1070,"subspace_rpc_primitives"],[1071,"subspace_rpc_primitives"],[1072,"core::fmt"],[1073,"subspace_core_primitives::pieces"],[1074,"core::ops::function"],[1075,"alloc::sync"],[1076,"event_listener_primitives::handler_id"],[1077,"libp2p_kad::record"],[1078,"subspace_farmer_components::plotting"],[1079,"core::error"],[1080,"core::cmp"],[1081,"std::path"],[1082,"parity_scale_codec::codec"],[1083,"serde::de"],[1084,"parity_scale_codec::codec"],[1085,"std::io::error"],[1086,"subspace_farmer_components::plotting"],[1087,"core::hash"],[1088,"std::io::error"],[1089,"core::marker"],[1090,"subspace_farmer_components::plotting"],[1091,"subspace_farmer_components::sector"],[1092,"anyhow"],[1093,"serde::ser"],[1094,"alloc::string"],[1095,"subspace_core_primitives"],[1096,"subspace_farmer_components::proving"],[1097,"subspace_farmer_components"],[1098,"subspace_proof_of_space"],[1099,"rayon_core"],[1100,"subspace_core_primitives::pieces"],[1101,"core::ops::function"],[1102,"tokio::runtime::task::join"],[1103,"core::num::error"],[1104,"core::task::wake"],[1105,"core::task::poll"],[1106,"rayon_core::registry"],[1107,"core::ops::function"],[1108,"subspace_networking::utils::piece_provider"],[1109,"subspace_networking::node"],[1110,"subspace_core_primitives::crypto::kzg"],[1111,"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 …","","","","","","","Get cpu core numbers in this set","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 …","Regroup CPU core sets to contain at most target_sets sets, …","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,112,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}}}}{lc{}}{Afc{}}000{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}0{Gdn}11111111111{{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{HdGn}4{HjGn}5{HlHb}6{GlHb}{{{h{Ej}}}Hb}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{}}000000{KnHl}{HdHl}{LnHl}{KjHl}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}:{HdHj};;:::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{{{Nd{c}}}n{}}{Afn}0`{{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{{{Aj{N`}}Af}{{Bn{N`}}}}{{gJn}{{Ib{{`{{f{}{{Eh{{A`{cOb}}}}}}Ih}}}}}Ih{{f{}{{Eh{c}}}}}{{O`{}{{Eh{e}}}}Ih}}`{{{Bf{Ml}}{Bf{Ml}}}{{Bn{N`}}}}9{{}{{`{{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",1056],[10,"Future",1057],[5,"Box",1058],[5,"Pin",1059],[5,"Identity",0],[1,"unit"],[6,"Result",1060],[5,"Path",1061],[10,"AsRef",1062],[1,"usize"],[1,"u8"],[1,"slice"],[5,"Formatter",1063],[8,"Result",1063],[1,"u64"],[1,"str"],[6,"Error",1064],[6,"Option",1065],[5,"PieceIndex",1066],[5,"PublicKey",1067],[5,"SecretKey",1067],[5,"Vec",1068],[5,"Signature",1069],[5,"RewardSignatureResponse",1070],[5,"SolutionResponse",1070],[5,"TypeId",1071],[10,"NodeClient",66],[10,"NodeClientExt",66],[5,"PieceCache",80],[5,"CacheWorker",80],[10,"Debug",1063],[5,"Key",1072],[5,"Piece",1066],[5,"PeerId",1073],[1,"tuple"],[10,"Fn",1074],[5,"Arc",1075],[5,"HandlerId",1076],[5,"ProviderRecord",1072],[5,"DiskPieceCache",787],[5,"Receiver",1077],[10,"PieceGetter",1078],[17,"Output"],[10,"Error",1079],[6,"SingleDiskFarmInfo",120],[6,"SectorPlottingDetails",120],[6,"SectorExpirationDetails",120],[6,"SingleDiskFarmId",120],[6,"SectorUpdate",120],[6,"Ordering",1080],[5,"PathBuf",1061],[6,"SingleDiskFarmSummary",120],[5,"Error",1081],[10,"Input",1082],[1,"u32"],[10,"Deserializer",1083],[5,"SingleDiskFarm",120],[10,"Output",1082],[10,"Sized",1084],[1,"bool"],[6,"PlottingError",120],[6,"SingleDiskFarmError",120],[6,"SingleDiskFarmScrubError",120],[6,"BackgroundTaskError",120],[5,"Error",1085],[6,"PlottingError",1078],[5,"Ulid",1086],[6,"DiskPieceCacheError",787],[6,"FarmingError",552],[1,"array"],[10,"Hasher",1087],[8,"Result",1085],[5,"SingleDiskFarmOptions",120],[10,"Clone",1088],[10,"Send",1084],[10,"Sync",1084],[5,"PublicKey",1089],[1,"u16"],[5,"PieceReader",851],[17,"Item"],[5,"PlottedSector",1078],[10,"Iterator",1090],[5,"SectorMetadataChecksummed",1091],[8,"Result",1092],[10,"Serializer",1093],[5,"String",1094],[8,"SectorIndex",1089],[5,"SingleDiskFarmInfoLock",120],[5,"PlotAudit",552],[5,"PlotAuditOptions",552],[5,"Solution",1089],[6,"ProvingError",1095],[10,"ProvableSolutions",1095],[6,"AuditingError",1096],[10,"ReadAtSync",1097],[10,"Table",1098],[5,"AuditingDetails",552],[6,"ProvingResult",552],[5,"ProvingDetails",552],[6,"FarmingNotification",552],[5,"DecodedFarmingError",552],[5,"ThreadPoolBuildError",1099],[5,"RayonFiles",770],[5,"Offset",787],[5,"PieceOffset",1066],[5,"PlottingThreadPoolManager",870],[5,"PlottingThreadPoolsGuard",870],[5,"PlottingThreadPoolPair",870],[5,"NonZeroUsize",1100],[10,"FnMut",1074],[5,"CpuCoreSet",924],[10,"ExactSizeIterator",1101],[5,"AsyncJoinOnDrop",924],[5,"JoinHandle",1102],[5,"ParseIntError",1103],[5,"Context",1104],[6,"Poll",1105],[5,"ThreadBuilder",1106],[10,"FnOnce",1074],[5,"Canceled",1077],[5,"FarmerPieceGetter",977],[6,"PieceGetterRetryPolicy",1078],[10,"PieceValidator",1107],[5,"PieceProvider",1107],[5,"ReadersAndPieces",1012],[8,"Mutex",1108],[5,"SegmentCommitmentPieceValidator",993],[5,"Node",1109],[5,"Kzg",1110],[5,"SegmentCommitment",1056],[5,"LruCache",1111],[6,"Ss58ParsingError",1033],[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-Display-for-SingleDiskFarmId"],[310,"impl-Debug-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%3CError%3E-for-PlottingError"],[326,"impl-From%3CPlottingError%3E-for-PlottingError"],[332,"impl-From%3CError%3E-for-SingleDiskFarmError"],[334,"impl-From%3CDiskPieceCacheError%3E-for-SingleDiskFarmError"],[336,"impl-From%3CFarmingError%3E-for-BackgroundTaskError"],[338,"impl-From%3CPlottingError%3E-for-BackgroundTaskError"],[339,"impl-From%3CBox%3Cdyn+Error+%2B+Send+%2B+Sync%3E%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-Debug-for-FarmingError"],[663,"impl-Display-for-FarmingError"],[672,"impl-From%3CAuditingError%3E-for-FarmingError"],[673,"impl-From%3CError%3E-for-FarmingError"],[674,"impl-From%3CThreadPoolBuildError%3E-for-FarmingError"],[675,"impl-From%3CProvingError%3E-for-FarmingError"],[780,"impl-ReadAtSync-for-RayonFiles"],[781,"impl-ReadAtSync-for-%26RayonFiles"],[814,"impl-Display-for-DiskPieceCacheError"],[815,"impl-Debug-for-DiskPieceCacheError"],[816,"impl-Display-for-Offset"],[817,"impl-Debug-for-Offset"],[1044,"impl-Debug-for-Ss58ParsingError"],[1045,"impl-Display-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"]]}],\ -["subspace_malicious_operator",{"doc":"Subspace malicious operator library.","t":"FFNNNNNNNNNNNNNNNNNHNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNOONNNNNNNNNNNNNNNNNNNNFOONNOOOOONNOONNNNNNONNNNNNNONONNNNNNN","n":["Cli","DomainCli","additional_args","augment_args","augment_args","augment_args_for_update","augment_args_for_update","author","author","borrow","borrow","borrow_mut","borrow_mut","command","command","command_for_update","command_for_update","copyright_start_year","copyright_start_year","create_malicious_operator_configuration","deref","deref","deref_mut","deref_mut","description","description","domain_args","domain_id","drop","drop","executable_name","executable_name","fmt","fmt","from","from","from_arg_matches","from_arg_matches","from_arg_matches_mut","from_arg_matches_mut","from_mut","from_mut","from_mut","from_mut","from_ref","from_ref","from_ref","from_ref","group_id","group_id","impl_name","impl_name","impl_version","impl_version","init","init","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","into_mut","into_mut","into_ref","into_ref","load_spec","load_spec","malicious_domain_instance_starter","new","run","run","support_url","support_url","try_from","try_from","try_into","try_into","type_id","type_id","type_name","type_name","unchecked_into","unchecked_into","unique_saturated_into","unique_saturated_into","update_from_arg_matches","update_from_arg_matches","update_from_arg_matches_mut","update_from_arg_matches_mut","vzip","vzip","DomainInstanceStarter","base_path","block_importing_notification_stream","borrow","borrow_mut","consensus_client","consensus_keystore","consensus_network","consensus_offchain_tx_pool_factory","consensus_sync_service","deref","deref_mut","domain_cli","domain_message_receiver","drop","from","from_mut","from_mut","from_ref","from_ref","gossip_message_sink","init","into","into_any","into_any_arc","into_any_rc","into_mut","into_ref","new_slot_notification_stream","start","tokio_handle","try_from","try_into","type_id","type_name","unchecked_into","unique_saturated_into","vzip"],"q":[[0,"subspace_malicious_operator"],[94,"subspace_malicious_operator::malicious_domain_instance_starter"],[132,"alloc::string"],[133,"core::iter::traits::iterator"],[134,"clap_builder::builder::command"],[135,"sp_domains"],[136,"sc_service::config"],[137,"sc_chain_spec"],[138,"alloc::boxed"],[139,"tokio::runtime::handle"],[140,"sc_service::config"],[141,"core::fmt"],[142,"core::fmt"],[143,"clap_builder"],[144,"core::result"],[145,"clap_builder::util::id"],[146,"core::option"],[147,"core::any"],[148,"alloc::sync"],[149,"alloc::rc"],[150,"core::any"],[151,"domain_client_operator::fetch_domain_bootstrap_info"],[152,"core::error"],[153,"sc_network::service::traits"],[154,"core::marker"],[155,"core::marker"]],"d":["Subspace Cli.","","","","","","","","","","","","","","","","","","","Create a Configuration object from the current object, …","","","","","","","Domain arguments","","","","","","","","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.","","","","","","","","","","Calls U::from(self).","Calls U::from(self).","","","","","","","","","","","","","","Constructs a new instance of DomainCli.","Run a node.","Run a domain node.","","","","","","","","","","","","","","","","","","","","","DomainInstanceStarter used to start a domain instance node …","","","","","","","","","","","","","","","Returns the argument unchanged.","Get a mutable reference to the inner from the outer.","","Get a reference to the inner from the outer.","","","","Calls U::from(self).","","","","","","","","","","","","","","",""],"i":[0,0,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,0,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,16,1,1,16,16,1,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,0,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,0,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29],"f":"``{b{{`{{h{}{{d{f}}}}}}}}{jj}000{{}f}0{ce{}{}}000{{}j}000{{}l}0{{nA`b{Ad{Ab}}Af}{{Aj{Ah}}}}{Alc{}}00055``{AlAn}066{{B`Bb}Bd}{{bBb}Bd}{cc{}}0{Bf{{Bj{B`Bh}}}}{Bf{{Bj{bBh}}}}10:22::2:2{{}{{Bn{Bl}}}}0<<<<{{}Al}0<<{{{Ad{c}}}{{Ad{C`}}}{}}0{{{Cb{c}}}{{Cb{C`}}}{}}0{{{Cd{c}}}{{Cd{C`}}}{}}0????{{B`Cf}{{Bj{{Ad{Ab}}f}}}}{{bCf}{{Bj{{Ad{Ab}}f}}}}`{cb{{h{}{{d{f}}}}}}``{{}f}0{c{{Bj{e}}}{}{}}000{cCh{}}0{cCf{}}0{ce{}{}}000{{B`Bf}{{Bj{AnBh}}}}{{bBf}{{Bj{AnBh}}}}1022```22`````{Alc{}}0``{AlAn}{cc{}}5050`{{}Al}6{{{Ad{c}}}{{Ad{C`}}}{}}{{{Cb{c}}}{{Cb{C`}}}{}}{{{Cd{c}}}{{Cd{C`}}}{}}99`{{{Cj{c}}{Cn{Cl}}}{{Bj{An{Ad{D`}}}}}{DbDdDf}}`==<;:::","c":[],"p":[[5,"DomainCli",0],[17,"Item"],[5,"String",132],[10,"Iterator",133],[5,"Command",134],[1,"i32"],[5,"DomainId",135],[5,"BasePath",136],[10,"ChainSpec",137],[5,"Box",138],[5,"Handle",139],[5,"Configuration",136],[8,"Result",140],[1,"usize"],[1,"unit"],[5,"Cli",0],[5,"Formatter",141],[8,"Result",141],[5,"ArgMatches",142],[8,"Error",143],[6,"Result",144],[5,"Id",145],[6,"Option",146],[10,"Any",147],[5,"Arc",148],[5,"Rc",149],[1,"str"],[5,"TypeId",147],[5,"DomainInstanceStarter",94],[8,"Block",150],[5,"BootstrapResult",151],[10,"Error",152],[10,"NetworkPeers",153],[10,"Send",154],[10,"Sync",154]],"b":[]}],\ +["subspace_malicious_operator",{"doc":"Subspace malicious operator library.","t":"FFNNNNNNNNNNNNNNNNNHNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNOONNNNNNNNNNNNNNNNNNNNFOONNOOOOONNOONNNNNNONNNNNNNONONNNNNNN","n":["Cli","DomainCli","additional_args","augment_args","augment_args","augment_args_for_update","augment_args_for_update","author","author","borrow","borrow","borrow_mut","borrow_mut","command","command","command_for_update","command_for_update","copyright_start_year","copyright_start_year","create_malicious_operator_configuration","deref","deref","deref_mut","deref_mut","description","description","domain_args","domain_id","drop","drop","executable_name","executable_name","fmt","fmt","from","from","from_arg_matches","from_arg_matches","from_arg_matches_mut","from_arg_matches_mut","from_mut","from_mut","from_mut","from_mut","from_ref","from_ref","from_ref","from_ref","group_id","group_id","impl_name","impl_name","impl_version","impl_version","init","init","into","into","into_any","into_any","into_any_arc","into_any_arc","into_any_rc","into_any_rc","into_mut","into_mut","into_ref","into_ref","load_spec","load_spec","malicious_domain_instance_starter","new","run","run","support_url","support_url","try_from","try_from","try_into","try_into","type_id","type_id","type_name","type_name","unchecked_into","unchecked_into","unique_saturated_into","unique_saturated_into","update_from_arg_matches","update_from_arg_matches","update_from_arg_matches_mut","update_from_arg_matches_mut","vzip","vzip","DomainInstanceStarter","base_path","block_importing_notification_stream","borrow","borrow_mut","consensus_client","consensus_keystore","consensus_network","consensus_offchain_tx_pool_factory","consensus_sync_service","deref","deref_mut","domain_cli","domain_message_receiver","drop","from","from_mut","from_mut","from_ref","from_ref","gossip_message_sink","init","into","into_any","into_any_arc","into_any_rc","into_mut","into_ref","new_slot_notification_stream","start","tokio_handle","try_from","try_into","type_id","type_name","unchecked_into","unique_saturated_into","vzip"],"q":[[0,"subspace_malicious_operator"],[94,"subspace_malicious_operator::malicious_domain_instance_starter"],[132,"alloc::string"],[133,"core::iter::traits::iterator"],[134,"clap_builder::builder::command"],[135,"sp_domains"],[136,"sc_service::config"],[137,"sc_chain_spec"],[138,"alloc::boxed"],[139,"tokio::runtime::handle"],[140,"sc_service::config"],[141,"core::fmt"],[142,"core::fmt"],[143,"clap_builder"],[144,"core::result"],[145,"clap_builder::util::id"],[146,"core::option"],[147,"core::any"],[148,"alloc::sync"],[149,"alloc::rc"],[150,"core::any"],[151,"domain_client_operator::fetch_domain_bootstrap_info"],[152,"core::error"],[153,"sc_network::service::traits"],[154,"core::marker"],[155,"core::marker"]],"d":["Subspace Cli.","","","","","","","","","","","","","","","","","","","Create a Configuration object from the current object, …","","","","","","","Domain arguments","","","","","","","","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.","","","","","","","","","","Calls U::from(self).","Calls U::from(self).","","","","","","","","","","","","","","Constructs a new instance of DomainCli.","Run a node.","Run a domain node.","","","","","","","","","","","","","","","","","","","","","DomainInstanceStarter used to start a domain instance node …","","","","","","","","","","","","","","","Returns the argument unchanged.","","Get a mutable reference to the inner from the outer.","","Get a reference to the inner from the outer.","","","Calls U::from(self).","","","","","","","","","","","","","","",""],"i":[0,0,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,0,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,16,1,1,16,16,1,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,0,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,16,1,0,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29,29],"f":"``{b{{`{{h{}{{d{f}}}}}}}}{jj}000{{}f}0{ce{}{}}000{{}j}000{{}l}0{{nA`b{Ad{Ab}}Af}{{Aj{Ah}}}}{Alc{}}00055``{AlAn}066{{B`Bb}Bd}{{bBb}Bd}{cc{}}0{Bf{{Bj{B`Bh}}}}{Bf{{Bj{bBh}}}}10:22::2:2{{}{{Bn{Bl}}}}0<<<<{{}Al}0<<{{{Ad{c}}}{{Ad{C`}}}{}}0{{{Cb{c}}}{{Cb{C`}}}{}}0{{{Cd{c}}}{{Cd{C`}}}{}}0????{{B`Cf}{{Bj{{Ad{Ab}}f}}}}{{bCf}{{Bj{{Ad{Ab}}f}}}}`{cb{{h{}{{d{f}}}}}}``{{}f}0{c{{Bj{e}}}{}{}}000{cCh{}}0{cCf{}}0{ce{}{}}000{{B`Bf}{{Bj{AnBh}}}}{{bBf}{{Bj{AnBh}}}}1022```22`````{Alc{}}0``{AlAn}{cc{}}0505`{{}Al}6{{{Ad{c}}}{{Ad{C`}}}{}}{{{Cb{c}}}{{Cb{C`}}}{}}{{{Cd{c}}}{{Cd{C`}}}{}}99`{{{Cj{c}}{Cn{Cl}}}{{Bj{An{Ad{D`}}}}}{DbDdDf}}`==<;:::","c":[],"p":[[5,"DomainCli",0],[17,"Item"],[5,"String",132],[10,"Iterator",133],[5,"Command",134],[1,"i32"],[5,"DomainId",135],[5,"BasePath",136],[10,"ChainSpec",137],[5,"Box",138],[5,"Handle",139],[5,"Configuration",136],[8,"Result",140],[1,"usize"],[1,"unit"],[5,"Cli",0],[5,"Formatter",141],[8,"Result",141],[5,"ArgMatches",142],[8,"Error",143],[6,"Result",144],[5,"Id",145],[6,"Option",146],[10,"Any",147],[5,"Arc",148],[5,"Rc",149],[1,"str"],[5,"TypeId",147],[5,"DomainInstanceStarter",94],[8,"Block",150],[5,"BootstrapResult",151],[10,"Error",152],[10,"NetworkPeers",153],[10,"Send",154],[10,"Sync",154]],"b":[]}],\ ["subspace_metrics",{"doc":"This Rust module serves as a bridge between two different …","t":"PPGPNNNNNNNNFNHNNNNNNNN","n":["Both","Libp2p","RegistryAdapter","Substrate","borrow","borrow","borrow_mut","borrow_mut","from","from","into","into","metrics","register","start_prometheus_metrics_server","try_from","try_from","try_into","try_into","type_id","type_id","vzip","vzip"],"q":[[0,"subspace_metrics"],[23,"actix_web::config"],[24,"core::net::socket_addr"],[25,"alloc::vec"],[26,"std::io::error"],[27,"core::future::future"],[28,"core::result"],[29,"core::any"]],"d":["We use both Substrate and Libp2p metrics registries.","Uses only the Libp2p metrics registry.","An metrics registry adapter for Libp2p and Substrate …","Uses only the Substrate metrics registry.","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Calls U::from(self).","Calls U::from(self).","","","Start prometheus metrics server on the provided address.","","","","","","","",""],"i":[6,6,0,6,6,1,6,1,6,1,6,1,0,1,0,6,1,6,1,6,1,6,1],"f":"````{ce{}{}}000{cc{}}011`{{bd}f}{{{j{h}}l}{{A`{{`{{Ab{}{{n{{A`{f}}}}}}}}}}}}{c{{Ad{e}}}{}{}}000{cAf{}}055","c":[],"p":[[5,"metrics",0],[5,"AppService",23],[1,"unit"],[6,"SocketAddr",24],[5,"Vec",25],[6,"RegistryAdapter",0],[17,"Output"],[8,"Result",26],[10,"Future",27],[6,"Result",28],[5,"TypeId",29]],"b":[]}],\ ["subspace_networking",{"doc":"Networking functionality of Subspace Network, primarily …","t":"PFGPKFGPPPGFFFGKTPKEFFPPPTEFGFIFPPRPIGFPPPPGPGPFPPFPMNOONNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONOONNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNOOONEOOONOOOOOOONNNMNNNNNNMNOHNOOONONNMNMNMNOOMNNONNNNNNNNNNNNNNNNNNOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNOOOOOOIFNNNNNNNNCNCHNNNNIGPKNNNNNNNNNNNNMMNNNNNNPFFKGPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNMNNNN","n":["CantPreallocateKnownPeersFile","Config","CreationError","Dynamic","GenericRequest","GenericRequestHandler","GetClosestPeersError","IncorrectResponseFormat","Io","Io","KademliaMode","KeyWrapper","KnownPeersManager","KnownPeersManagerConfig","KnownPeersManagerPersistenceError","KnownPeersRegistry","LOG_TARGET","LastSegmentHeaders","LocalRecordProvider","Multihash","Node","NodeRunner","NodeRunnerDropped","NodeRunnerDropped","NodeRunnerDropped","PROTOCOL_NAME","PeerAddress","PeerAddressRemovedEvent","PeerDiscovered","PieceByIndexRequest","PieceByIndexRequestHandler","PieceByIndexResponse","ProtocolFailure","RelayServerExpected","Response","RoutablePeer","SegmentHeaderBySegmentIndexesRequestHandler","SegmentHeaderRequest","SegmentHeaderResponse","SegmentIndexes","SendCommand","SendCommand","SendCommand","SendRequestError","Static","SubscribeError","Subscription","TopicSubscription","TransportCreationError","TransportError","UniqueRecordBinaryHeap","UnroutablePeer","add_known_peer","add_known_peer","address","allow_non_global_addresses_in_dht","ban_peer","bootstrap","bootstrap_addresses","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","boxed","cache_size","clear","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","connected_peers","construct","contains_key","create","decode","decode","decode","decode","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_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","default","default","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","disable_bootstrap_on_start","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","enable_known_peers_source","encode","encode","encode","encode_to","encode_to","encode_to","encode_to","eq","eq","eq","eq","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","equivalent","external_addresses","external_addresses","failed_address_cache_removal_interval","failed_address_kademlia_removal_interval","file_size","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","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","from","from","from","from","from","from","from","from","from","from","from","get_closest_peers","get_providers","get_requests_batch_handle","get_value","gossipsub","id","identify","ignore_peer_list","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","initial_random_query_interval","insert","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","is_dynamic","is_static","kademlia","kademlia_mode","keypair","keys","libp2p","libp2p_metrics","listen_on","listen_on_fallback_to_random_port","listeners","local_records_provider","max_established_incoming_connections","max_established_outgoing_connections","max_pending_incoming_connections","max_pending_outgoing_connections","metrics","networking_parameters_registry","new","new","new","next_known_addresses_batch","next_known_addresses_batch","on_connected_peer","on_disconnected_peer","on_discovered_peer","on_new_listener","on_num_established_peer_connections_change","on_unreachable_address","on_unreachable_address","path","peer_id","peer_id","peer_id","piece","piece_index","poll_next","protocol_version","publish","put_value","record","remove","remove_all_known_peer_addresses","remove_all_known_peer_addresses","remove_known_peer_addresses","remove_known_peer_addresses","request_response_protocols","reserved_peers","run","run","run","segment_headers","send_generic_request","set_limit","should_include_key","size","size_hint","size_hint","size_hint","size_hint","size_hint","source","source","source","source","source","start_over_address_batching","start_over_address_batching","start_over_address_batching","subscribe","temporary_ban_backoff","temporary_bans_cache_size","timeout","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","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","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","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","using_encoded","using_encoded","using_encoded","utils","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","vzip","yamux_config","address","peer_id","peer_id","segment_header_number","segment_indexes","PeerAddress","SubspaceMetrics","borrow","borrow_mut","deref","deref_mut","drop","from","init","into","multihash","new","piece_provider","strip_peer_id","try_from","try_into","type_id","vzip","Multihash","MultihashCode","PieceIndex","ToMultihash","borrow","borrow_mut","clone","clone_into","deref","deref_mut","drop","eq","fmt","from","init","into","to_multihash","to_multihash_by_code","to_owned","try_from","try_from","try_into","type_id","vzip","Limited","NoPieceValidator","PieceProvider","PieceValidator","RetryPolicy","Unlimited","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","clone","clone_into","default","deref","deref","deref","deref_mut","deref_mut","deref_mut","drop","drop","drop","eq","equivalent","equivalent","fmt","from","from","from","get_piece_from_archival_storage","get_piece_from_dsn_cache","get_piece_from_peer","init","init","init","into","into","into","new","to_owned","try_from","try_from","try_from","try_into","try_into","try_into","type_id","type_id","type_id","validate_piece","validate_piece","vzip","vzip","vzip"],"q":[[0,"subspace_networking"],[529,"subspace_networking::PeerDiscovered"],[532,"subspace_networking::SegmentHeaderRequest"],[534,"subspace_networking::utils"],[552,"subspace_networking::utils::multihash"],[576,"subspace_networking::utils::piece_provider"],[632,"libp2p_identity::peer_id"],[633,"multiaddr"],[634,"alloc::vec"],[635,"core::future::future"],[636,"alloc::boxed"],[637,"core::pin"],[638,"futures_channel::mpsc"],[639,"core::result"],[640,"core::clone"],[641,"core::marker"],[642,"core::marker"],[643,"core::ops::function"],[644,"parity_scale_codec::error"],[645,"parity_scale_codec::codec"],[646,"parity_scale_codec::codec"],[647,"core::fmt"],[648,"core::fmt"],[649,"libp2p_core::transport"],[650,"futures_channel::oneshot"],[651,"libp2p_gossipsub::error"],[652,"futures_core::stream"],[653,"libp2p_kad::behaviour"],[654,"core::iter::traits::exact_size"],[655,"alloc::string"],[656,"libp2p_identity::keypair"],[657,"prometheus_client::registry"],[658,"alloc::sync"],[659,"event_listener_primitives::handler_id"],[660,"core::task::wake"],[661,"core::task::poll"],[662,"libp2p_gossipsub"],[663,"libp2p_kad::record"],[664,"libp2p_kad::record"],[665,"core::any"],[666,"core::ops::function"],[667,"subspace_core_primitives::pieces"]],"d":["Can’t preallocate known peers file, probably not enough …","Node configuration.","Errors that might happen during network creation.","Kademlia mode will be changed using Autonat protocol when …","Generic request with associated response","Defines generic request-response protocol handler.","Defines errors for get-closest-peers operation.","Underlying protocol returned an incorrect format, …","I/O error.","I/O error.","Defines Kademlia mode","Wrapper data structure that allows to work with keys as …","Handles networking parameters. It manages network …","Configuration for KnownPeersManager.","Networking parameters persistence errors.","Defines operations with the networking parameters.","Specifies log-parameters for tracing.","Defines how many segment headers to return.","Trait to be implemented on providers of local records","","Implementation of a network node on Subspace Network.","Runner for the Node.","Node runner was dropped","Node runner was dropped","Node runner was dropped","Defines request-response protocol name.","","Defines the event triggered when the peer address is …","Represents Kademlia events (RoutablePeer, …","Piece-by-hash protocol request.","Create a new piece-by-hash request handler.","Piece-by-hash protocol response.","Underlying protocol returned an error, impossible to get …","Circuit relay client error.","Response type that corresponds to this request","Kademlia’s routable or pending routable peer event.","Create a new segment-header-by-segment-indexes request …","Segment header by segment indexes protocol request.","Segment header by segment indexes protocol response.","Segment headers by segment indexes.","Failed to send command to the node runner","Failed to send command to the node runner","Failed to send command to the node runner","Defines errors for send-request operation.","The Kademlia mode is static for the duration of the …","Defines errors for subscribe operation.","Failed to create subscription.","Topic subscription, will unsubscribe when last instance is …","Transport creation error.","Transport error when attempting to listen on multiaddr.","Limited-size max binary heap for Kademlia records’ keys.","Kademlia’s unroutable peer event.","Registers a peer ID and associated addresses","","Peer address","Should non-global addresses be added to the DHT?","Ban peer with specified peer ID.","Bootstraps Kademlia network","Addresses to bootstrap Kademlia network","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Creates a reference to the NetworkingParametersRegistry …","Defines cache size.","Remove all contents, while keeping allocated capacity","","","","","","","","","","","","","","","","","","","","","","","Returns a collection of currently connected peers.","Create a new network node and node runner instances.","Checks whether the heap contains the given key.","Creates new GenericRequestHandler by given handler.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Defines whether we should run blocking Kademlia …","","","","","","","","","","","","","","","","","","","","","","","","Defines whether we return known peers batches on …","","","","","","","","","","","","","","","","","","","","Node’s own addresses observed remotely.","Known external addresses to the local peer. The addresses …","Defines interval before the next peer address removes …","Defines interval before the next peer address removal …","Size of the backing file on disk","","","","","","","","","","","","","","","","","","","","","","","","","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.","Get closest peers by multihash key using Kademlia DHT.","Get item providers by its key. Initiate ‘providers’ …","Returns the request batch handle with common “connection …","Return a value from the Kademlia network of the DSN.","The configuration for the Gossip behaviour.","Node’s own local ID.","The configuration for the Identify behaviour.","Peer ID list to filter on address adding.","","","","","","","","","","","","","","","","","","","","","","How frequently should random queries be done using …","Insert a key in the heap evicting (popping) if the size …","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).","Returns true if the mode is Dynamic.","Returns true if the mode is Static.","The configuration for the Kademlia behaviour.","Kademlia mode. The default value is set to Static(Client). …","Identity keypair of a node used for authenticated …","Iterator over all keys in arbitrary order","","Optional libp2p prometheus metrics. None will disable …","List of Multiaddr on which to listen for incoming …","Fallback to random port if specified (or default) port is …","Node’s own addresses where it listens for incoming …","Externally provided implementation of the local records …","Established incoming swarm connection limit.","Established outgoing swarm connection limit.","Pending incoming swarm connection limit.","Pending outgoing swarm connection limit.","Internal prometheus metrics. None will disable metrics …","A reference to the NetworkingParametersRegistry …","Object constructor.","Creates a new Config.","Constructs a heap with given PeerId and size limit.","Returns a batch of the combined collection of known …","","Callback is called when a peer is connected.","Callback is called when a peer is disconnected.","Callback is called when a routable or unraoutable peer is …","Callback is called when node starts listening on new …","Callback is called when number of established peer …","Triggers when we removed the peer address from the …","","Defines whether we enable cache persistence.","Converts public key from keypair to PeerId. It serves as …","Extracts peer ID from event.","Peer ID","Returned data.","Request key - piece index","","Defines protocol version for the network peers. Affects …","Subcribe a messgo to some topic on the DSN.","Puts a value into the Kademlia network of the DSN.","Gets a provider record for key that is stored locally","Removes a key from the heap.","Unregisters associated addresses for peer ID.","","Unregisters associated addresses for peer ID.","","The configuration for the RequestResponsesBehaviour …","Defines set of peers with a permanent connection (and …","Drive async work in the persistence provider","","Drives the main networking future forward.","Returned data.","Sends the generic request to the peer and awaits the …","Set limit to new value, decreasing to value lower than …","Checks whether we include the key.","Returns heap-size","","","","","","","","","","","","Reset the batching process to the initial state.","Reset the batching process to the initial state.","Subcribe to some topic on the DSN.","Backoff policy for temporary banning of unreachable peers.","How many temporarily banned unreachable peers to keep in …","Adds a timeout to the setup and protocol upgrade process …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Miscellaneous utilities for networking.","","","","","","","","","","","","","","","","","","","","","","Yamux multiplexing configuration.","Peer address","Peer ID","Peer ID","Number of segment headers to return.","Segment indexes to get.","Convenience alias for peer ID and its multiaddresses.","Metrics for Subspace networking","","","","","","Returns the argument unchanged.","","Calls U::from(self).","Defines multihash codes for Subspace DSN.","Constructor","Provides methods to retrieve pieces from DSN.","Helper function. Converts multiaddresses to a tuple with …","","","","","Type alias for libp2p Multihash. Constant 64 was copied …","Subspace Network multihash codes.","Piece index code.","Helper trait for converting to multihash.","","","","","","","","","","Returns the argument unchanged.","","Calls U::from(self).","Convert to multihash by the default multihash code.","Convert to multihash by the specified multihash code.","","","","","","","Retry N times (including zero)","Stub implementation for piece validation.","Piece provider with cancellation and optional piece …","Validates piece against using its commitment.","Defines retry policy on error during piece acquiring.","No restrictions on retries","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Get piece from archival storage (L1). The algorithm tries …","Returns piece by its index from farmer’s piece cache …","Get piece from a particular peer.","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Creates new piece provider.","","","","","","","","","","","Validates piece against using its commitment.","","","",""],"i":[48,0,0,17,0,0,0,51,48,27,0,0,0,0,0,0,32,20,0,0,0,0,49,50,51,32,0,0,0,0,0,0,51,27,32,22,0,0,0,20,49,50,51,0,17,0,50,0,27,27,0,22,1,8,15,24,9,9,24,8,24,25,86,15,16,48,17,27,42,49,50,51,9,18,19,20,21,22,23,13,8,24,25,86,15,16,48,17,27,42,49,50,51,9,18,19,20,21,22,23,13,8,16,13,15,16,17,9,18,19,20,21,22,23,13,15,16,17,9,18,19,20,21,22,23,13,9,0,13,86,18,19,20,21,18,19,20,21,18,19,20,21,18,19,20,21,24,16,8,24,25,86,15,16,48,17,27,42,49,50,51,9,18,19,20,21,22,23,13,8,24,25,86,15,16,48,17,27,42,49,50,51,9,18,19,20,21,22,23,13,24,8,8,24,25,86,15,16,48,17,27,42,42,49,50,51,9,18,19,20,21,22,23,13,16,18,19,21,18,19,20,21,18,19,20,21,18,18,19,19,20,20,21,21,9,24,16,16,8,24,25,15,16,48,48,17,27,27,42,49,49,50,50,51,51,9,18,19,20,21,22,23,13,8,24,25,86,15,16,48,48,17,27,27,27,42,49,49,49,50,50,50,50,51,51,51,51,9,18,19,20,21,22,23,13,9,9,9,9,24,9,24,16,8,24,25,86,15,16,48,17,27,42,49,50,51,9,18,19,20,21,22,23,13,24,13,8,24,25,86,15,16,48,17,27,42,49,50,51,9,18,19,20,21,22,23,13,17,17,24,24,24,13,0,24,24,24,9,24,24,24,24,24,24,24,8,24,13,1,8,9,9,9,9,9,1,8,16,0,22,15,19,18,42,24,9,9,28,13,1,8,1,8,24,24,1,8,25,21,9,13,13,13,42,18,19,20,21,48,27,49,50,51,8,1,1,9,24,24,24,18,19,20,21,15,16,17,9,18,19,20,21,22,23,13,48,27,49,50,51,8,24,25,86,15,16,48,17,27,42,49,50,51,9,18,19,20,21,22,23,13,8,24,25,86,15,16,48,17,27,42,49,50,51,9,18,19,20,21,22,23,13,8,24,25,86,15,16,48,17,27,42,49,50,51,9,18,19,20,21,22,23,13,18,19,21,0,8,24,25,86,15,16,48,17,27,42,49,50,51,9,18,19,20,21,22,23,13,24,87,88,87,89,90,0,0,75,75,75,75,75,75,75,75,0,75,0,0,75,75,75,75,0,0,77,0,77,77,77,77,77,77,77,77,77,77,77,77,78,78,77,77,77,77,77,77,80,0,0,0,0,80,85,81,80,85,81,80,80,80,80,85,81,80,85,81,80,85,81,80,80,80,80,80,85,81,80,81,81,81,85,81,80,85,81,80,81,80,85,81,80,85,81,80,85,81,80,84,85,85,81,80],"f":"````````````````````````````````````````````````````{{bd{h{f}}}{{n{{l{j}}}}}}{{A`d{h{f}}}{{n{{l{j}}}}}}``{{Abd}{{Ah{AdAf}}}}{Ab{{Ah{Ad`}}}}`{ce{}{}}00000000000000000000000000000000000000000{A`{{l{b}}}}`{{{Aj{c}}}AdAl}{AnAn}{B`B`}{BbBb}{AbAb}{BdBd}{BfBf}{BhBh}{BjBj}{BlBl}{{{Bn{c}}}{{Bn{c}}}Al}{{{Aj{c}}}{{Aj{c}}}Al}{{ce}Ad{}{}}0000000000{Ab{{Ah{{h{d}}`}}}}{{{C`{c}}}{{Ah{{Cd{Ab{Cb{c}}}}Cf}}}{ChCjCl}}{{{Aj{c}}c}CnAl}{g{{l{`}}}D`{{j{}{{Db{Dd}}}}Cj}{{Df{dc}{{Db{e}}}}CjCl}}{c{{Ah{BdDh}}}Dj}{c{{Ah{BfDh}}}Dj}{c{{Ah{BhDh}}}Dj}{c{{Ah{BjDh}}}Dj}{{{Dn{Dl}}}{{Ah{cDh}}}{}}000{{E`{Dn{Dl}}}{{Ah{cDh}}}{}}000{{E`c}{{Ah{eDh}}}Dj{}}000{{}{{C`{Ad}}}}{{}B`}{Ebc{}}00000000000000000000000000000000000000000`{A`Ad}{EbAd}000000000{EdAd}11111111111`{Bd{{h{Dl}}}}{Bf{{h{Dl}}}}{Bj{{h{Dl}}}}{{Bdc}Ad{EfEh}}{{Bfc}Ad{EfEh}}{{Bhc}Ad{EfEh}}{{Bjc}Ad{EfEh}}{{BdBd}Cn}{{BfBf}Cn}{{BhBh}Cn}{{BjBj}Cn}{{ce}Cn{}{}}0000000{Ab{{h{f}}}}```{EjEb}{{{C`{c}}El}En{}}{{{Cb{c}}El}En{ChCjCl}}{{AnEl}En}{{B`El}En}{{F`El}En}0{{BbEl}En}{{CfEl}En}0{{EdEl}En}{{FbEl}En}0{{FdEl}En}0{{FfEl}En}0{{AbEl}En}{{BdEl}En}{{BfEl}En}{{BhEl}En}{{BjEl}En}{{BlEl}En}{{{Bn{c}}El}EnFh}{{{Aj{c}}El}EnFh}{cc{}}000000{FjF`}1{{{Fl{Fj}}}Cf}2{FjCf}3{AfFb}4{FnFb}{AfFd}{FnFd}7{G`Fd}8{FnFf}{DhFf}{AfFf};;;;;;;;{{AbGb}{{Ah{{`{{Gf{}{{Gd{d}}}}}}Fb}}}}{{AbGb}{{Ah{{`{{Gf{}{{Gd{d}}}}}}`}}}}`{{AbGb}{{Ah{{`{{Gf{}{{Gd{Gh}}}}}}`}}}}`{Abd}``{{}Eb}00000000000000000000`{{{Aj{c}}c}{{Dd{c}}}Al}{ce{}{}}00000000000000000000{BbCn}0```{{{Aj{c}}}{{`{{Gj{}{{Gd{c}}}}}}}Al}````{Ab{{h{f}}}}```````{B`{{Ah{A`F`}}}}{{GlGnc{Dd{H`}}}{{C`{c}}}Ch}{{dEb}{{Aj{c}}}Al}{b{{n{{l{j}}}}}}{A`{{n{{l{j}}}}}}{{Ab{Hb{Df}}}Hd}0000{{b{Hb{Df}}}{{Dd{Hd}}}}{{A`{Hb{Df}}}{{Dd{Hd}}}}`{Gnd}{Bld}```{{{n{Ed}}Hf}{{Hh{{Dd{c}}}}}{}}`{{AbHj{h{Dl}}}{{Ah{Ad`}}}}{{AbGb{h{Dl}}}{{Ah{{`{{Gf{}{{Gd{Ad}}}}}}`}}}}{{ChHl}{{Dd{Hn}}}}{{{Aj{c}}c}AdAl}{{bd}Ad}{{A`d}Ad}{{bd{h{f}}}{{n{{l{j}}}}}}{{A`d{h{f}}}{{n{{l{j}}}}}}``?>{{{Cb{c}}}Ad{ChCjCl}}`{{Abdc}{{Ah{Ff}}}D`}{{{Aj{c}}Eb}AdAl}{{{Aj{c}}c}CnAl}{{{Aj{c}}}EbAl}{Ed{{Cd{Eb{Dd{Eb}}}}}}{BdEb}{BfEb}{BhEb}{BjEb}{F`{{Dd{I`}}}}{Cf{{Dd{I`}}}}{Fb{{Dd{I`}}}}{Fd{{Dd{I`}}}}{Ff{{Dd{I`}}}}{A`Ad}{bAd}0{{AbHj}{{Ah{EdFd}}}}```{{c{Dn{Dl}}}{{h{Dl}}}{}}000{ce{}{}}0000000000{cGl{}}0000{c{{Ah{e}}}{}{}}00000000000000000000000000000000000000000{cIb{}}00000000000000000000{{Bde}c{}{{Id{{Dn{Dl}}}{{Db{c}}}}}}{{Bfe}c{}{{Id{{Dn{Dl}}}{{Db{c}}}}}}{{Bje}c{}{{Id{{Dn{Dl}}}{{Db{c}}}}}}`666666666666666666666````````66{Ebc{}}0{EbAd}{cc{}}{{}Eb}:`{H`If}`{{{h{f}}}{{h{Ih}}}}::9<````<<{IjIj}{{ce}Ad{}{}}776{{IjIj}Cn}{{IjEl}En}76{ce{}{}}{IlGb}{{IlIj}Gb}2{c{{Ah{e}}}{}{}}{In{{Ah{Ijc}}}{}}1{cIb{}}5``````555555{J`J`}9{{}J`}{Ebc{}}00000{EbAd}00{{J`J`}Cn}{{ce}Cn{}{}}0{{J`El}En}{cc{}}00{{{Jb{c}}JdEb}{{Dd{Jf}}}Jh}{{{Jb{c}}JdJ`}{{Ah{{Dd{Jf}}{l{I`}}}}}Jh}{{{Jb{c}}dJd}{{Dd{Jf}}}Jh}{{}Eb}00{ce{}{}}00{{Ab{Dd{c}}}{{Jb{c}}}Jh}1{c{{Ah{e}}}{}{}}00000???{{JhdJdJf}{{n{{l{j}}}}}}{{JjdJdJf}{{n{{l{j}}}}}}444","c":[],"p":[[10,"KnownPeersRegistry",0],[5,"PeerId",632],[5,"Multiaddr",633],[5,"Vec",634],[10,"Future",635],[5,"Box",636],[5,"Pin",637],[5,"KnownPeersManager",0],[5,"Node",0],[1,"unit"],[5,"SendError",638],[6,"Result",639],[5,"UniqueRecordBinaryHeap",0],[10,"Clone",640],[5,"PeerAddressRemovedEvent",0],[5,"KnownPeersManagerConfig",0],[6,"KademliaMode",0],[5,"PieceByIndexRequest",0],[5,"PieceByIndexResponse",0],[6,"SegmentHeaderRequest",0],[5,"SegmentHeaderResponse",0],[6,"PeerDiscovered",0],[5,"KeyWrapper",0],[5,"Config",0],[5,"NodeRunner",0],[1,"tuple"],[6,"CreationError",0],[10,"LocalRecordProvider",0],[10,"Send",641],[10,"Sync",641],[1,"bool"],[10,"GenericRequest",0],[17,"Output"],[6,"Option",642],[10,"Fn",643],[5,"Error",644],[10,"Input",645],[1,"u8"],[1,"slice"],[1,"u32"],[1,"usize"],[5,"TopicSubscription",0],[10,"Output",645],[10,"Sized",641],[5,"NonZeroUsize",646],[5,"Formatter",647],[8,"Result",647],[6,"KnownPeersManagerPersistenceError",0],[6,"GetClosestPeersError",0],[6,"SubscribeError",0],[6,"SendRequestError",0],[10,"Debug",647],[5,"Error",648],[6,"TransportError",649],[5,"Canceled",650],[6,"SubscriptionError",651],[8,"Multihash",552],[17,"Item"],[10,"Stream",652],[5,"PeerRecord",653],[10,"ExactSizeIterator",654],[5,"String",655],[5,"Keypair",656],[5,"Registry",657],[5,"Arc",658],[5,"HandlerId",659],[5,"Context",660],[6,"Poll",661],[8,"Sha256Topic",662],[5,"Key",663],[5,"ProviderRecord",663],[10,"Error",664],[5,"TypeId",665],[10,"FnOnce",643],[5,"SubspaceMetrics",534],[8,"PeerAddress",534],[6,"MultihashCode",552],[10,"ToMultihash",552],[1,"u64"],[6,"RetryPolicy",576],[5,"PieceProvider",576],[5,"PieceIndex",666],[5,"Piece",666],[10,"PieceValidator",576],[5,"NoPieceValidator",576],[5,"GenericRequestHandler",0],[15,"RoutablePeer",529],[15,"UnroutablePeer",529],[15,"LastSegmentHeaders",532],[15,"SegmentIndexes",532]],"b":[[243,"impl-Display-for-KnownPeersManagerPersistenceError"],[244,"impl-Debug-for-KnownPeersManagerPersistenceError"],[246,"impl-Debug-for-CreationError"],[247,"impl-Display-for-CreationError"],[249,"impl-Debug-for-GetClosestPeersError"],[250,"impl-Display-for-GetClosestPeersError"],[251,"impl-Debug-for-SubscribeError"],[252,"impl-Display-for-SubscribeError"],[253,"impl-Debug-for-SendRequestError"],[254,"impl-Display-for-SendRequestError"],[272,"impl-From%3CTransportError%3CError%3E%3E-for-CreationError"],[274,"impl-From%3CError%3E-for-CreationError"],[276,"impl-From%3CSendError%3E-for-GetClosestPeersError"],[278,"impl-From%3CCanceled%3E-for-GetClosestPeersError"],[279,"impl-From%3CSendError%3E-for-SubscribeError"],[280,"impl-From%3CCanceled%3E-for-SubscribeError"],[282,"impl-From%3CSubscriptionError%3E-for-SubscribeError"],[284,"impl-From%3CCanceled%3E-for-SendRequestError"],[285,"impl-From%3CError%3E-for-SendRequestError"],[286,"impl-From%3CSendError%3E-for-SendRequestError"]]}],\ ["subspace_proof_of_space",{"doc":"Subspace proof of space implementation based on Chia","t":"PRGPTKKNNCCNNNNNMNNMMNNNNNMCNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN","n":["Chia","Generator","PosTableType","Shim","TABLE_TYPE","Table","TableGenerator","borrow","borrow_mut","chia","chiapos","clone","clone_into","deref","deref_mut","drop","find_proof","fmt","from","generate","generate","generate_parallel","generate_parallel","generator","init","into","is_proof_valid","shim","to_owned","try_from","try_into","type_id","ChiaTable","ChiaTableGenerator","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","default","deref","deref","deref_mut","deref_mut","drop","drop","find_proof","fmt","fmt","from","from","generate","generate","generate_parallel","generate_parallel","init","init","into","into","is_proof_valid","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","Tables","TablesCache","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","create","create","create","create","create","create","create","create","create","create","create","create_parallel","create_parallel","create_parallel","create_parallel","create_parallel","create_parallel","create_parallel","create_parallel","create_parallel","create_parallel","create_parallel","create_simple","create_simple","create_simple","create_simple","create_simple","create_simple","create_simple","create_simple","create_simple","create_simple","create_simple","default","deref","deref","deref_mut","deref_mut","drop","drop","find_proof","find_proof","find_proof","find_proof","find_proof","find_proof","find_proof","find_proof","find_proof","find_proof","find_proof","find_quality","find_quality","find_quality","find_quality","find_quality","find_quality","find_quality","find_quality","find_quality","find_quality","find_quality","fmt","fmt","from","from","init","init","into","into","to_owned","try_from","try_from","try_into","try_into","type_id","type_id","verify","verify","verify","verify","verify","verify","verify","verify","verify","verify","verify","ShimTable","ShimTableGenerator","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","default","deref","deref","deref_mut","deref_mut","drop","drop","find_proof","fmt","fmt","from","from","generate","generate","init","init","into","into","is_proof_valid","to_owned","try_from","try_from","try_into","try_into","type_id","type_id"],"q":[[0,"subspace_proof_of_space"],[32,"subspace_proof_of_space::chia"],[68,"subspace_proof_of_space::chiapos"],[164,"subspace_proof_of_space::shim"],[198,"subspace_core_primitives"],[199,"core::option"],[200,"core::fmt"],[201,"core::fmt"],[202,"core::any"],[203,"core::iter::traits::iterator"]],"d":["Chia table","Instance that can be used to generate tables with better …","Proof of space table type","Shim table","Proof of space table type","Proof of space kind","Stateful table generator with better performance","","","Chia proof of space implementation","Chia proof of space reimplementation in Rust","","","","","","Try to find proof at challenge_index if it exists","","Returns the argument unchanged.","Generate new table with 32 bytes seed.","Generate new table with 32 bytes seed.","Generate new table with 32 bytes seed using parallelism.","Generate new table with 32 bytes seed using parallelism.","Returns a stateful table generator with better performance","","Calls U::from(self).","Check whether proof created earlier is valid and return …","Shim proof of space implementation that works much faster …","","","","","Subspace proof of space table.","Subspace proof of space table generator.","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","","","","","","Calls U::from(self).","Calls U::from(self).","","","","","","","","","Collection of Chia tables","Caches that can be used to optimize creation of multiple …","","","","","","","Create Chia proof of space tables. There also exists …","Create Chia proof of space tables. There also exists …","Create Chia proof of space tables. There also exists …","Create Chia proof of space tables. There also exists …","Create Chia proof of space tables. There also exists …","Create Chia proof of space tables. There also exists …","Create Chia proof of space tables. There also exists …","Create Chia proof of space tables. There also exists …","Create Chia proof of space tables. There also exists …","Create Chia proof of space tables. There also exists …","Create Chia proof of space tables. There also exists …","Almost the same as Self::create(), but uses parallelism …","Almost the same as Self::create(), but uses parallelism …","Almost the same as Self::create(), but uses parallelism …","Almost the same as Self::create(), but uses parallelism …","Almost the same as Self::create(), but uses parallelism …","Almost the same as Self::create(), but uses parallelism …","Almost the same as Self::create(), but uses parallelism …","Almost the same as Self::create(), but uses parallelism …","Almost the same as Self::create(), but uses parallelism …","Almost the same as Self::create(), but uses parallelism …","Almost the same as Self::create(), but uses parallelism …","Create Chia proof of space tables.","Create Chia proof of space tables.","Create Chia proof of space tables.","Create Chia proof of space tables.","Create Chia proof of space tables.","Create Chia proof of space tables.","Create Chia proof of space tables.","Create Chia proof of space tables.","Create Chia proof of space tables.","Create Chia proof of space tables.","Create Chia proof of space tables.","Create new instance","","","","","","","Find proof of space for given challenge.","Find proof of space for given challenge.","Find proof of space for given challenge.","Find proof of space for given challenge.","Find proof of space for given challenge.","Find proof of space for given challenge.","Find proof of space for given challenge.","Find proof of space for given challenge.","Find proof of space for given challenge.","Find proof of space for given challenge.","Find proof of space for given challenge.","Find proof of space quality for given challenge.","Find proof of space quality for given challenge.","Find proof of space quality for given challenge.","Find proof of space quality for given challenge.","Find proof of space quality for given challenge.","Find proof of space quality for given challenge.","Find proof of space quality for given challenge.","Find proof of space quality for given challenge.","Find proof of space quality for given challenge.","Find proof of space quality for given challenge.","Find proof of space quality for given challenge.","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Calls U::from(self).","Calls U::from(self).","","","","","","","","Verify proof of space for given seed and challenge.","Verify proof of space for given seed and challenge.","Verify proof of space for given seed and challenge.","Verify proof of space for given seed and challenge.","Verify proof of space for given seed and challenge.","Verify proof of space for given seed and challenge.","Verify proof of space for given seed and challenge.","Verify proof of space for given seed and challenge.","Verify proof of space for given seed and challenge.","Verify proof of space for given seed and challenge.","Verify proof of space for given seed and challenge.","Subspace proof of space table.","Subspace proof of space table generator.","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","","","","Calls U::from(self).","Calls U::from(self).","","","","","","","",""],"i":[1,5,0,1,5,0,0,1,1,0,0,1,1,1,1,1,5,1,1,9,5,9,5,5,1,1,5,0,1,1,1,1,0,0,16,17,16,17,16,16,16,16,17,16,17,16,17,17,16,17,16,17,16,17,16,17,16,17,16,17,17,16,16,17,16,17,16,17,0,0,18,21,18,21,18,18,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,18,18,21,18,21,18,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,21,18,21,18,21,18,21,18,21,18,18,21,18,21,18,21,21,21,21,21,21,21,21,21,21,21,21,0,0,24,25,24,25,24,24,24,24,25,24,25,24,25,25,24,25,24,25,24,25,24,25,24,25,25,24,24,25,24,25,24,25],"f":"```````{ce{}{}}0``{bb}{{ce}d{}{}}{fc{}}0{fd}{{{j{}{{h{c}}}}l}{{A`{n}}}Ab}{{bAd}Af}{cc{}}{{AbAh}cj}{Ah{{j{}{{h{c}}}}}Ab}10{{}c{}}{{}f};{{Ahln}Aj}`<{c{{Al{e}}}{}{}}0{cAn{}}``>>>>{B`B`}={{}B`}====<<{{Bbl}{{A`{n}}}}{{B`Ad}Af}{{BbAd}Af}<<{{B`Ah}Bb}{AhBb}10::{ce{}{}}0:0999988``0000{BdBd}{{ce}d{}{}}{{{Bh{Bf}}Bd}Bj}000000000000000000000{{{Bh{Bf}}}Bj}0000000000{{}Bd}{fc{}}000{fd}0{{Bj{Bh{Bf}}}{{`{{Bn{}{{Bl{{Bh{Bf}}}}}}}}}}000000000000000000000{{BdAd}Af}{{BjAd}Af}{cc{}}0{{}f}0<<<{c{{Al{e}}}{}{}}000{cAn{}}0{{{Bh{Bf}}{Bh{Bf}}{Bh{Bf}}}{{A`{{Bh{Bf}}}}}}0000000000``????{C`C`}>{{}C`};;;;::{{Cbl}{{A`{n}}}}{{C`Ad}Af}{{CbAd}Af}99{{C`Ah}Cb}{AhCb}::{ce{}{}}0{{Ahln}Aj}1;;;;::","c":[],"p":[[6,"PosTableType",0],[1,"unit"],[1,"usize"],[17,"Generator"],[10,"Table",0],[1,"u32"],[5,"PosProof",198],[6,"Option",199],[10,"TableGenerator",0],[5,"Formatter",200],[8,"Result",200],[5,"PosSeed",198],[1,"bool"],[6,"Result",201],[5,"TypeId",202],[5,"ChiaTableGenerator",32],[5,"ChiaTable",32],[5,"TablesCache",68],[1,"u8"],[1,"array"],[5,"Tables",68],[17,"Item"],[10,"Iterator",203],[5,"ShimTableGenerator",164],[5,"ShimTable",164]],"b":[[76,"impl-Tables%3C21%3E"],[77,"impl-Tables%3C24%3E"],[78,"impl-Tables%3C20%3E"],[79,"impl-Tables%3C19%3E"],[80,"impl-Tables%3C18%3E"],[81,"impl-Tables%3C17%3E"],[82,"impl-Tables%3C16%3E"],[83,"impl-Tables%3C25%3E"],[84,"impl-Tables%3C22%3E"],[85,"impl-Tables%3C15%3E"],[86,"impl-Tables%3C23%3E"],[87,"impl-Tables%3C22%3E"],[88,"impl-Tables%3C23%3E"],[89,"impl-Tables%3C20%3E"],[90,"impl-Tables%3C24%3E"],[91,"impl-Tables%3C19%3E"],[92,"impl-Tables%3C18%3E"],[93,"impl-Tables%3C21%3E"],[94,"impl-Tables%3C17%3E"],[95,"impl-Tables%3C25%3E"],[96,"impl-Tables%3C15%3E"],[97,"impl-Tables%3C16%3E"],[98,"impl-Tables%3C18%3E"],[99,"impl-Tables%3C24%3E"],[100,"impl-Tables%3C16%3E"],[101,"impl-Tables%3C23%3E"],[102,"impl-Tables%3C20%3E"],[103,"impl-Tables%3C17%3E"],[104,"impl-Tables%3C22%3E"],[105,"impl-Tables%3C25%3E"],[106,"impl-Tables%3C19%3E"],[107,"impl-Tables%3C21%3E"],[108,"impl-Tables%3C15%3E"],[116,"impl-Tables%3C16%3E"],[117,"impl-Tables%3C23%3E"],[118,"impl-Tables%3C18%3E"],[119,"impl-Tables%3C25%3E"],[120,"impl-Tables%3C21%3E"],[121,"impl-Tables%3C17%3E"],[122,"impl-Tables%3C22%3E"],[123,"impl-Tables%3C19%3E"],[124,"impl-Tables%3C15%3E"],[125,"impl-Tables%3C24%3E"],[126,"impl-Tables%3C20%3E"],[127,"impl-Tables%3C18%3E"],[128,"impl-Tables%3C17%3E"],[129,"impl-Tables%3C25%3E"],[130,"impl-Tables%3C20%3E"],[131,"impl-Tables%3C24%3E"],[132,"impl-Tables%3C15%3E"],[133,"impl-Tables%3C21%3E"],[134,"impl-Tables%3C22%3E"],[135,"impl-Tables%3C19%3E"],[136,"impl-Tables%3C16%3E"],[137,"impl-Tables%3C23%3E"],[153,"impl-Tables%3C16%3E"],[154,"impl-Tables%3C18%3E"],[155,"impl-Tables%3C24%3E"],[156,"impl-Tables%3C25%3E"],[157,"impl-Tables%3C15%3E"],[158,"impl-Tables%3C23%3E"],[159,"impl-Tables%3C22%3E"],[160,"impl-Tables%3C19%3E"],[161,"impl-Tables%3C21%3E"],[162,"impl-Tables%3C20%3E"],[163,"impl-Tables%3C17%3E"]]}],\ diff --git a/settings.html b/settings.html index 51589d0c3f..69cf5b40ea 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/sp_domains/extrinsics/fn.deduplicate_and_shuffle_extrinsics.html b/sp_domains/extrinsics/fn.deduplicate_and_shuffle_extrinsics.html index 4e842b372a..81c29c32f1 100644 --- a/sp_domains/extrinsics/fn.deduplicate_and_shuffle_extrinsics.html +++ b/sp_domains/extrinsics/fn.deduplicate_and_shuffle_extrinsics.html @@ -1,6 +1,6 @@ deduplicate_and_shuffle_extrinsics in sp_domains::extrinsics - Rust

Function sp_domains::extrinsics::deduplicate_and_shuffle_extrinsics

source · 
pub fn deduplicate_and_shuffle_extrinsics<Extrinsic>(
-    extrinsics: Vec<(Option<AccountId>, Extrinsic)>,
+    extrinsics: Vec<(Option<AccountId>, Extrinsic)>,
     shuffling_seed: Randomness
 ) -> VecDeque<Extrinsic>
where
     Extrinsic: Debug + PartialEq + Clone,
\ No newline at end of file diff --git a/sp_domains/storage/struct.RawGenesis.html b/sp_domains/storage/struct.RawGenesis.html index 54402a41d8..a05424db09 100644 --- a/sp_domains/storage/struct.RawGenesis.html +++ b/sp_domains/storage/struct.RawGenesis.html @@ -1,6 +1,6 @@ RawGenesis in sp_domains::storage - Rust

Struct sp_domains::storage::RawGenesis

source · 
pub struct RawGenesis { /* private fields */ }
Expand description

Raw storage content for genesis block

-

Implementations§

source§

impl RawGenesis

source

pub fn set_domain_id(&mut self, domain_id: DomainId)

source

pub fn set_evm_chain_id(&mut self, chain_id: EVMChainId)

source

pub fn get_runtime_code(&self) -> Option<&[u8]>

source

pub fn take_runtime_code(&mut self) -> Option<Vec<u8>>

source

pub fn state_root<H>(&self, state_version: StateVersion) -> H::Out
where +

Implementations§

source§

impl RawGenesis

source

pub fn set_domain_id(&mut self, domain_id: DomainId)

source

pub fn set_evm_chain_id(&mut self, chain_id: EVMChainId)

source

pub fn get_runtime_code(&self) -> Option<&[u8]>

source

pub fn take_runtime_code(&mut self) -> Option<Vec<u8>>

source

pub fn state_root<H>(&self, state_version: StateVersion) -> H::Out
where H: Hasher, H::Out: Codec + Ord,

source

pub fn dummy(code: Vec<u8>) -> Self

source§

impl RawGenesis

source

pub fn from_storage(storage: Storage) -> Self

Construct RawGenesis from a given storage NOTE: This function is part from sc-chain-spec::GenesisSource::resolve

diff --git a/sp_domains/struct.ExecutionReceipt.html b/sp_domains/struct.ExecutionReceipt.html index 61271e1ac9..0e2e148f7a 100644 --- a/sp_domains/struct.ExecutionReceipt.html +++ b/sp_domains/struct.ExecutionReceipt.html @@ -10,7 +10,7 @@ pub final_state_root: DomainHash, pub execution_trace: Vec<DomainHash>, pub execution_trace_root: H256, - pub block_fees: BlockFees<Balance>, + pub block_fees: BlockFees<Balance>, }
Expand description

Receipt of a domain block execution.

Fields§

§domain_block_number: DomainNumber

The index of the current domain block that forms the basis of this ER.

§domain_block_hash: DomainHash

The block hash corresponding to domain_block_number.

@@ -25,7 +25,7 @@
§execution_trace: Vec<DomainHash>

List of storage roots collected during the domain block execution.

§execution_trace_root: H256

The Merkle root of the execution trace for the current domain block.

Used for verifying fraud proofs.

-
§block_fees: BlockFees<Balance>

Compute and Domain storage fees are shared across operators and Consensus +

§block_fees: BlockFees<Balance>

Compute and Domain storage fees are shared across operators and Consensus storage fees are given to the consensus block author.

Implementations§

source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source

pub fn bundles_extrinsics_roots(&self) -> Vec<&DomainHash>

source

pub fn valid_bundle_digest_at(&self, index: usize) -> Option<DomainHash>
where DomainHash: Copy,

source

pub fn valid_bundle_digests(&self) -> Vec<DomainHash>
where @@ -49,7 +49,7 @@ Hash: Decode, Vec<InboxedBundle<DomainHash>>: Decode, Vec<DomainHash>: Decode, - BlockFees<Balance>: Decode,

source§

fn decode<__CodecInputEdqy: Input>( + BlockFees<Balance>: Decode,

source§

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

Attempt to deserialise the value from input.
§

fn decode_into<I>( input: &mut I, @@ -63,7 +63,7 @@ Hash: Encode, Vec<InboxedBundle<DomainHash>>: Encode, Vec<DomainHash>: Encode, - BlockFees<Balance>: Encode,

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>( + BlockFees<Balance>: Encode,

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.
§

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

Convert self to an owned vector.
§

fn using_encoded<R, F>(&self, f: F) -> R
where @@ -79,7 +79,7 @@ Hash: TypeInfo + 'static, Vec<InboxedBundle<DomainHash>>: TypeInfo + 'static, Vec<DomainHash>: TypeInfo + 'static, - BlockFees<Balance>: TypeInfo + 'static, + BlockFees<Balance>: TypeInfo + 'static, Balance: TypeInfo + 'static,

§

type Identity = ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

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<Number, Hash, DomainNumber, DomainHash, Balance> EncodeLike for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where DomainNumber: Encode, DomainHash: Encode, @@ -87,7 +87,7 @@ Hash: Encode, Vec<InboxedBundle<DomainHash>>: Encode, Vec<DomainHash>: Encode, - BlockFees<Balance>: Encode,

source§

impl<Number: Eq, Hash: Eq, DomainNumber: Eq, DomainHash: Eq, Balance: Eq> Eq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralPartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

Auto Trait Implementations§

§

impl<Number, Hash, DomainNumber, DomainHash, Balance> RefUnwindSafe for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where + BlockFees<Balance>: Encode,

source§

impl<Number: Eq, Hash: Eq, DomainNumber: Eq, DomainHash: Eq, Balance: Eq> Eq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralPartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

Auto Trait Implementations§

§

impl<Number, Hash, DomainNumber, DomainHash, Balance> RefUnwindSafe for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where Balance: RefUnwindSafe, DomainHash: RefUnwindSafe, DomainNumber: RefUnwindSafe, diff --git a/sp_domains/type.ExecutionReceiptFor.html b/sp_domains/type.ExecutionReceiptFor.html index 7a945f0e18..0ab1dd10ae 100644 --- a/sp_domains/type.ExecutionReceiptFor.html +++ b/sp_domains/type.ExecutionReceiptFor.html @@ -10,7 +10,7 @@ pub final_state_root: <DomainHeader as Header>::Hash, pub execution_trace: Vec<<DomainHeader as Header>::Hash>, pub execution_trace_root: H256, - pub block_fees: BlockFees<Balance>, + pub block_fees: BlockFees<Balance>, }

Fields§

§domain_block_number: <DomainHeader as Header>::Number

The index of the current domain block that forms the basis of this ER.

§domain_block_hash: <DomainHeader as Header>::Hash

The block hash corresponding to domain_block_number.

§domain_block_extrinsic_root: <DomainHeader as Header>::Hash

Extrinsic root field of the header of domain block referenced by this ER.

@@ -24,6 +24,6 @@
§execution_trace: Vec<<DomainHeader as Header>::Hash>

List of storage roots collected during the domain block execution.

§execution_trace_root: H256

The Merkle root of the execution trace for the current domain block.

Used for verifying fraud proofs.

-
§block_fees: BlockFees<Balance>

Compute and Domain storage fees are shared across operators and Consensus +

§block_fees: BlockFees<Balance>

Compute and Domain storage fees are shared across operators and Consensus storage fees are given to the consensus block author.

\ No newline at end of file diff --git a/src/subspace_farmer/utils.rs.html b/src/subspace_farmer/utils.rs.html index 8f60aeb043..da3643a8f0 100644 --- a/src/subspace_farmer/utils.rs.html +++ b/src/subspace_farmer/utils.rs.html @@ -454,6 +454,31 @@

Files

452 453 454 +455 +456 +457 +458 +459 +460 +461 +462 +463 +464 +465 +466 +467 +468 +469 +470 +471 +472 +473 +474 +475 +476 +477 +478 +479 
pub mod farmer_piece_getter;
 pub mod piece_validator;
 pub mod readers_and_pieces;
@@ -479,6 +504,9 @@ 
Files

 #[cfg(feature = "numa")]
 use tracing::warn;
 
+/// It doesn't make a lot of sense to have a huge number of farming threads, 32 is plenty
+const MAX_DEFAULT_FARMING_THREADS: usize = 32;
+
 /// Joins async join handle on drop
 pub struct AsyncJoinOnDrop<T> {
     handle: Option<task::JoinHandle<T>>,
@@ -607,7 +635,28 @@ 
Files

 }
 
 impl CpuCoreSet {
-    pub fn cpu_cores(&self) -> &[usize] {
+    /// Regroup CPU core sets to contain at most `target_sets` sets, useful when there are many L3
+    /// cache groups and not as many farms
+    pub fn regroup(cpu_core_sets: &[Self], target_sets: usize) -> Vec<Self> {
+        cpu_core_sets
+            // Chunk CPU core sets
+            .chunks(cpu_core_sets.len().div_ceil(target_sets))
+            .map(|sets| Self {
+                // Combine CPU cores
+                cores: sets
+                    .iter()
+                    .flat_map(|set| set.cores.iter())
+                    .copied()
+                    .collect(),
+                // Preserve topology object
+                #[cfg(feature = "numa")]
+                topology: sets[0].topology.clone(),
+            })
+            .collect()
+    }
+
+    /// Get cpu core numbers in this set
+    pub fn cpu_cores(&self) -> &[usize] {
         &self.cores
     }
 
@@ -657,13 +706,14 @@ 
Files

                 // Get number of CPU cores
                 .map(|cpuset| cpuset.iter_set().count())
                 .find(|&count| count > 0)
-                .unwrap_or_else(num_cpus::get);
+                .unwrap_or_else(num_cpus::get)
+                .min(MAX_DEFAULT_FARMING_THREADS);
         }
         Err(error) => {
             warn!(%error, "Failed to get NUMA topology");
         }
     }
-    num_cpus::get()
+    num_cpus::get().min(MAX_DEFAULT_FARMING_THREADS)
 }
 
 /// Get all cpu cores, grouped into sets according to NUMA nodes or L3 cache groups on large CPUs.
diff --git a/subspace_archiving/archiver/enum.ArchiverInstantiationError.html b/subspace_archiving/archiver/enum.ArchiverInstantiationError.html
index 0d975aa8b5..4b06d61e52 100644
--- a/subspace_archiving/archiver/enum.ArchiverInstantiationError.html
+++ b/subspace_archiving/archiver/enum.ArchiverInstantiationError.html
@@ -1,14 +1,14 @@
 ArchiverInstantiationError in subspace_archiving::archiver - Rust

     
Enum subspace_archiving::archiver::ArchiverInstantiationError
source · 
pub enum ArchiverInstantiationError {
     FailedToInitializeErasureCoding(String),
-    InvalidLastArchivedBlock(BlockNumber),
+    InvalidLastArchivedBlock(BlockNumber),
     InvalidBlockSmallSize {
         block_bytes: u32,
         archived_block_bytes: u32,
     },
 }
Expand description
Archiver instantiation error

 
Variants§
§
FailedToInitializeErasureCoding(String)
Failed to initialize erasure coding

-
§
InvalidLastArchivedBlock(BlockNumber)
Invalid last archived block, its size is the same as encoded block

+
§
InvalidLastArchivedBlock(BlockNumber)
Invalid last archived block, its size is the same as encoded block

 
§
InvalidBlockSmallSize
Fields
§block_bytes: u32
Full block size

 
§archived_block_bytes: u32
Already archived portion of the block

 
Invalid block, its size is smaller than already archived number of bytes

diff --git a/subspace_archiving/archiver/enum.SegmentItem.html b/subspace_archiving/archiver/enum.SegmentItem.html
index 85b5e17ec4..6ae0385275 100644
--- a/subspace_archiving/archiver/enum.SegmentItem.html
+++ b/subspace_archiving/archiver/enum.SegmentItem.html
@@ -13,7 +13,7 @@
         bytes: Vec<u8>,
         /* private fields */
     },
-    ParentSegmentHeader(SegmentHeader),
+    ParentSegmentHeader(SegmentHeader),
 }
Expand description

Kinds of items that are contained within a segment

Variants§

§

Padding

Special dummy enum variant only used as an implementation detail for padding purposes

§

Block

Fields

§bytes: Vec<u8>

Block bytes

@@ -22,7 +22,7 @@

Contains the beginning of the block inside, remainder will be found in subsequent segments

§

BlockContinuation

Fields

§bytes: Vec<u8>

Block bytes

Continuation of the partial block spilled over into the next segment

-
§

ParentSegmentHeader(SegmentHeader)

Segment header of the parent

+
§

ParentSegmentHeader(SegmentHeader)

Segment header of the parent

Trait Implementations§

source§

impl Clone for SegmentItem

source§

fn clone(&self) -> SegmentItem

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 SegmentItem

source§

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

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

impl Decode for SegmentItem

source§

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

Attempt to deserialise the value from input.
§

fn decode_into<I>( diff --git a/subspace_archiving/archiver/fn.is_piece_valid.html b/subspace_archiving/archiver/fn.is_piece_valid.html index 9279d9f2d0..61ed20c700 100644 --- a/subspace_archiving/archiver/fn.is_piece_valid.html +++ b/subspace_archiving/archiver/fn.is_piece_valid.html @@ -1,8 +1,8 @@ is_piece_valid in subspace_archiving::archiver - Rust

Function subspace_archiving::archiver::is_piece_valid

source · 
pub fn is_piece_valid(
-    kzg: &Kzg,
-    piece: &PieceArray,
-    segment_commitment: &SegmentCommitment,
+    kzg: &Kzg,
+    piece: &PieceArray,
+    segment_commitment: &SegmentCommitment,
     position: u32
 ) -> bool
Expand description

Validate witness embedded within a piece produced by archiver

\ No newline at end of file diff --git a/subspace_archiving/archiver/fn.is_record_commitment_hash_valid.html b/subspace_archiving/archiver/fn.is_record_commitment_hash_valid.html index de80473076..3d6c96251f 100644 --- a/subspace_archiving/archiver/fn.is_record_commitment_hash_valid.html +++ b/subspace_archiving/archiver/fn.is_record_commitment_hash_valid.html @@ -1,9 +1,9 @@ is_record_commitment_hash_valid in subspace_archiving::archiver - Rust

Function subspace_archiving::archiver::is_record_commitment_hash_valid

source · 
pub fn is_record_commitment_hash_valid(
-    kzg: &Kzg,
-    record_commitment_hash: &Scalar,
-    commitment: &SegmentCommitment,
-    witness: &RecordWitness,
+    kzg: &Kzg,
+    record_commitment_hash: &Scalar,
+    commitment: &SegmentCommitment,
+    witness: &RecordWitness,
     position: u32
 ) -> bool
Expand description

Validate witness for record commitment hash produced by archiver

\ No newline at end of file diff --git a/subspace_archiving/archiver/struct.Archiver.html b/subspace_archiving/archiver/struct.Archiver.html index 26b30696af..0bf949fb52 100644 --- a/subspace_archiving/archiver/struct.Archiver.html +++ b/subspace_archiving/archiver/struct.Archiver.html @@ -1,28 +1,28 @@ Archiver in subspace_archiving::archiver - Rust

Struct subspace_archiving::archiver::Archiver

source · 
pub struct Archiver { /* private fields */ }
Expand description

Block archiver for Subspace blockchain.

It takes new confirmed (at K depth) blocks and concatenates them into a buffer, buffer is -sliced into segments of [RecordedHistorySegment::SIZE] size, segments are sliced into source -records of [RawRecord::SIZE], records are erasure coded, committed to with [Kzg], then +sliced into segments of RecordedHistorySegment::SIZE size, segments are sliced into source +records of RawRecord::SIZE, records are erasure coded, committed to with Kzg, then commitments with witnesses are appended and records become pieces that are returned alongside corresponding segment header header.

Panics

Panics when operating on blocks, whose length doesn’t fit into u32 (should never be the case in blockchain context anyway).

-

Implementations§

source§

impl Archiver

source

pub fn new(kzg: Kzg) -> Result<Self, ArchiverInstantiationError>

Create a new instance with specified record size and recorded history segment size.

+

Implementations§

source§

impl Archiver

source

pub fn new(kzg: Kzg) -> Result<Self, ArchiverInstantiationError>

Create a new instance with specified record size and recorded history segment size.

Note: this is the only way to instantiate object archiver, while block archiver can be instantiated with BlockArchiver::with_initial_state() in case of restarts.

source

pub fn with_initial_state( - kzg: Kzg, - segment_header: SegmentHeader, + kzg: Kzg, + segment_header: SegmentHeader, encoded_block: &[u8], - object_mapping: BlockObjectMapping + object_mapping: BlockObjectMapping ) -> Result<Self, ArchiverInstantiationError>

Create a new instance of the archiver with initial state in case of restart.

block corresponds to last_archived_block and will be processed accordingly to its state.

-
source

pub fn last_archived_block_number(&self) -> Option<BlockNumber>

Get last archived block if there was any

+
source

pub fn last_archived_block_number(&self) -> Option<BlockNumber>

Get last archived block if there was any

source

pub fn add_block( &mut self, bytes: Vec<u8>, - object_mapping: BlockObjectMapping, + object_mapping: BlockObjectMapping, incremental: bool ) -> Vec<NewArchivedSegment>

Adds new block to internal buffer, potentially producing pieces and segment header headers.

Incremental archiving can be enabled if amortized block addition cost is preferred over diff --git a/subspace_archiving/archiver/struct.NewArchivedSegment.html b/subspace_archiving/archiver/struct.NewArchivedSegment.html index 47a033966c..75cf69b2b7 100644 --- a/subspace_archiving/archiver/struct.NewArchivedSegment.html +++ b/subspace_archiving/archiver/struct.NewArchivedSegment.html @@ -1,13 +1,13 @@ NewArchivedSegment in subspace_archiving::archiver - Rust

Struct subspace_archiving::archiver::NewArchivedSegment

source · 
pub struct NewArchivedSegment {
-    pub segment_header: SegmentHeader,
-    pub pieces: ArchivedHistorySegment,
-    pub object_mapping: Vec<PieceObjectMapping>,
+    pub segment_header: SegmentHeader,
+    pub pieces: ArchivedHistorySegment,
+    pub object_mapping: Vec<PieceObjectMapping>,
 }
Expand description

Newly archived segment as a combination of segment header hash, segment index and corresponding archived history segment containing pieces

-

Fields§

§segment_header: SegmentHeader

Segment header

-
§pieces: ArchivedHistorySegment

Segment of archived history containing pieces

-
§object_mapping: Vec<PieceObjectMapping>

Mappings for objects stored in corresponding pieces.

+

Fields§

§segment_header: SegmentHeader

Segment header

+
§pieces: ArchivedHistorySegment

Segment of archived history containing pieces

+
§object_mapping: Vec<PieceObjectMapping>

Mappings for objects stored in corresponding pieces.

NOTE: Only half (source pieces) will have corresponding mapping item in this Vec.

Trait Implementations§

source§

impl Clone for NewArchivedSegment

source§

fn clone(&self) -> NewArchivedSegment

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 NewArchivedSegment

source§

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

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

impl Decode for NewArchivedSegment

source§

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy diff --git a/subspace_archiving/piece_reconstructor/struct.PiecesReconstructor.html b/subspace_archiving/piece_reconstructor/struct.PiecesReconstructor.html index a2beb06f57..3cf748c291 100644 --- a/subspace_archiving/piece_reconstructor/struct.PiecesReconstructor.html +++ b/subspace_archiving/piece_reconstructor/struct.PiecesReconstructor.html @@ -1,16 +1,16 @@ PiecesReconstructor in subspace_archiving::piece_reconstructor - Rust

Struct subspace_archiving::piece_reconstructor::PiecesReconstructor

source · 
pub struct PiecesReconstructor { /* private fields */ }
Expand description

Reconstructor helps to retrieve blocks from archived pieces.

-

Implementations§

source§

impl PiecesReconstructor

source

pub fn new(kzg: Kzg) -> Result<Self, ReconstructorInstantiationError>

source

pub fn reconstruct_segment( +

Implementations§

source§

impl PiecesReconstructor

source

pub fn new(kzg: Kzg) -> Result<Self, ReconstructorInstantiationError>

source

pub fn reconstruct_segment( &self, - segment_pieces: &[Option<Piece>] -) -> Result<ArchivedHistorySegment, ReconstructorError>

Returns all the pieces for a segment using given set of pieces of a segment of the archived + segment_pieces: &[Option<Piece>] +) -> Result<ArchivedHistorySegment, ReconstructorError>

Returns all the pieces for a segment using given set of pieces of a segment of the archived history (any half of all pieces are required to be present, the rest will be recovered automatically due to use of erasure coding if needed).

source

pub fn reconstruct_piece( &self, - segment_pieces: &[Option<Piece>], + segment_pieces: &[Option<Piece>], piece_position: usize -) -> Result<Piece, ReconstructorError>

Returns the missing piece for a segment using given set of pieces of a segment of the archived +) -> Result<Piece, ReconstructorError>

Returns the missing piece for a segment using given set of pieces of a segment of the archived history (any half of all pieces are required to be present).

Trait Implementations§

source§

impl Clone for PiecesReconstructor

source§

fn clone(&self) -> PiecesReconstructor

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 PiecesReconstructor

source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl !RefUnwindSafe for PiecesReconstructor

§

impl Send for PiecesReconstructor

§

impl Sync for PiecesReconstructor

§

impl Unpin for PiecesReconstructor

§

impl !UnwindSafe for PiecesReconstructor

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 diff --git a/subspace_archiving/reconstructor/enum.ReconstructorError.html b/subspace_archiving/reconstructor/enum.ReconstructorError.html index b610c07e00..35f898e140 100644 --- a/subspace_archiving/reconstructor/enum.ReconstructorError.html +++ b/subspace_archiving/reconstructor/enum.ReconstructorError.html @@ -3,13 +3,13 @@ DataShardsReconstruction(String), SegmentDecoding(Error), IncorrectSegmentOrder { - expected_segment_index: SegmentIndex, - actual_segment_index: SegmentIndex, + expected_segment_index: SegmentIndex, + actual_segment_index: SegmentIndex, }, }
Expand description

Reconstructor-related instantiation error

Variants§

§

DataShardsReconstruction(String)

Error during data shards reconstruction

§

SegmentDecoding(Error)

Segment size is not bigger than record size

-
§

IncorrectSegmentOrder

Fields

§expected_segment_index: SegmentIndex
§actual_segment_index: SegmentIndex

Incorrect segment order, each next segment must have monotonically increasing segment index

+
§

IncorrectSegmentOrder

Fields

§expected_segment_index: SegmentIndex
§actual_segment_index: SegmentIndex

Incorrect segment order, each next segment must have monotonically increasing segment index

Trait Implementations§

source§

impl Clone for ReconstructorError

source§

fn clone(&self) -> ReconstructorError

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 ReconstructorError

source§

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

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

impl Display for ReconstructorError

source§

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

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

impl Error for ReconstructorError

1.30.0 · source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl PartialEq for ReconstructorError

source§

fn eq(&self, other: &ReconstructorError) -> 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 StructuralPartialEq for ReconstructorError

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where diff --git a/subspace_archiving/reconstructor/struct.ReconstructedContents.html b/subspace_archiving/reconstructor/struct.ReconstructedContents.html index 775865658e..ebf1db7c38 100644 --- a/subspace_archiving/reconstructor/struct.ReconstructedContents.html +++ b/subspace_archiving/reconstructor/struct.ReconstructedContents.html @@ -1,11 +1,11 @@ ReconstructedContents in subspace_archiving::reconstructor - Rust

Struct subspace_archiving::reconstructor::ReconstructedContents

source · 
pub struct ReconstructedContents {
-    pub segment_header: Option<SegmentHeader>,
-    pub blocks: Vec<(BlockNumber, Vec<u8>)>,
+    pub segment_header: Option<SegmentHeader>,
+    pub blocks: Vec<(BlockNumber, Vec<u8>)>,
 }
Expand description

Data structure that contains information reconstructed from given segment (potentially using information from segments that were added previously)

-

Fields§

§segment_header: Option<SegmentHeader>

Segment header stored in a segment

-
§blocks: Vec<(BlockNumber, Vec<u8>)>

Reconstructed encoded blocks with their block numbers

+

Fields§

§segment_header: Option<SegmentHeader>

Segment header stored in a segment

+
§blocks: Vec<(BlockNumber, Vec<u8>)>

Reconstructed encoded blocks with their block numbers

Trait Implementations§

source§

impl Clone for ReconstructedContents

source§

fn clone(&self) -> ReconstructedContents

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 ReconstructedContents

source§

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

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

impl Default for ReconstructedContents

source§

fn default() -> ReconstructedContents

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

impl PartialEq for ReconstructedContents

source§

fn eq(&self, other: &ReconstructedContents) -> 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 Eq for ReconstructedContents

source§

impl StructuralEq for ReconstructedContents

source§

impl StructuralPartialEq for ReconstructedContents

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where diff --git a/subspace_archiving/reconstructor/struct.Reconstructor.html b/subspace_archiving/reconstructor/struct.Reconstructor.html index 11e33e3acd..9eb88977d4 100644 --- a/subspace_archiving/reconstructor/struct.Reconstructor.html +++ b/subspace_archiving/reconstructor/struct.Reconstructor.html @@ -2,7 +2,7 @@

Struct subspace_archiving::reconstructor::Reconstructor

source · 
pub struct Reconstructor { /* private fields */ }
Expand description

Reconstructor helps to retrieve blocks from archived pieces.

Implementations§

source§

impl Reconstructor

source

pub fn new() -> Result<Self, ReconstructorInstantiationError>

source

pub fn add_segment( &mut self, - segment_pieces: &[Option<Piece>] + segment_pieces: &[Option<Piece>] ) -> Result<ReconstructedContents, ReconstructorError>

Given a set of pieces of a segment of the archived history (any half of all pieces are required to be present, the rest will be recovered automatically due to use of erasure coding if needed), reconstructs and returns segment header and a list of encoded blocks with diff --git a/subspace_erasure_coding/struct.ErasureCoding.html b/subspace_erasure_coding/struct.ErasureCoding.html index 8520117c01..600419c143 100644 --- a/subspace_erasure_coding/struct.ErasureCoding.html +++ b/subspace_erasure_coding/struct.ErasureCoding.html @@ -5,28 +5,28 @@

Number of shards supported is 2^scale, half of shards are source data and the other half are parity.

source

pub fn max_shards(&self) -> usize

Max number of shards supported (both source and parity together)

-
source

pub fn extend(&self, source: &[Scalar]) -> Result<Vec<Scalar>, String>

Extend sources using erasure coding.

+
source

pub fn extend(&self, source: &[Scalar]) -> Result<Vec<Scalar>, String>

Extend sources using erasure coding.

Returns parity data.

-
source

pub fn recover(&self, shards: &[Option<Scalar>]) -> Result<Vec<Scalar>, String>

Recovery of missing shards from given shards (at least 1/2 should be Some).

+
source

pub fn recover(&self, shards: &[Option<Scalar>]) -> Result<Vec<Scalar>, String>

Recovery of missing shards from given shards (at least 1/2 should be Some).

Both in input and output source shards are interleaved with parity shards: source, parity, source, parity, …

source

pub fn recover_poly( &self, - shards: &[Option<Scalar>] -) -> Result<Polynomial, String>

Recovery of missing shards from given shards (at least 1/2 should be Some) in form of + shards: &[Option<Scalar>] +) -> Result<Polynomial, String>

Recovery of missing shards from given shards (at least 1/2 should be Some) in form of normalized polynomial (allows to not do inverse FFT afterwards if polynomial is desired).

Both in input and output source shards are interleaved with parity shards: source, parity, source, parity, …

source

pub fn recover_source( &self, - shards: &[Option<Scalar>] -) -> Result<impl ExactSizeIterator<Item = Scalar>, String>

Recovery of source shards from given shards (at least 1/2 should be Some).

+ shards: &[Option<Scalar>] +) -> Result<impl ExactSizeIterator<Item = Scalar>, String>

Recovery of source shards from given shards (at least 1/2 should be Some).

The same as ErasureCoding::recover(), but returns only source shards in form of an iterator.

source

pub fn extend_commitments( &self, - commitments: &[Commitment] -) -> Result<Vec<Commitment>, String>

Extend commitments using erasure coding.

+ commitments: &[Commitment] +) -> Result<Vec<Commitment>, String>

Extend commitments using erasure coding.

Returns both source and parity commitments interleaved.

Trait Implementations§

source§

impl Clone for ErasureCoding

source§

fn clone(&self) -> ErasureCoding

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 ErasureCoding

source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl RefUnwindSafe for ErasureCoding

§

impl Send for ErasureCoding

§

impl Sync for ErasureCoding

§

impl Unpin for ErasureCoding

§

impl UnwindSafe for ErasureCoding

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 diff --git a/subspace_farmer/single_disk_farm/enum.BackgroundTaskError.html b/subspace_farmer/single_disk_farm/enum.BackgroundTaskError.html index 8e5f4dcdea..7db8e93931 100644 --- a/subspace_farmer/single_disk_farm/enum.BackgroundTaskError.html +++ b/subspace_farmer/single_disk_farm/enum.BackgroundTaskError.html @@ -11,7 +11,7 @@
§

Farming(FarmingError)

Farming error

§

RewardSigning(Box<dyn Error + Send + Sync + 'static>)

Reward signing

§

BackgroundTaskPanicked

Fields

§task: String

Background task panicked

-

Trait Implementations§

source§

impl Debug for BackgroundTaskError

source§

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

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

impl Display for BackgroundTaskError

source§

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

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

impl Error for BackgroundTaskError

source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl From<Box<dyn Error + Sync + Send>> for BackgroundTaskError

source§

fn from(source: Box<dyn Error + Send + Sync + 'static>) -> Self

Converts to this type from the input type.
source§

impl From<FarmingError> for BackgroundTaskError

source§

fn from(source: FarmingError) -> Self

Converts to this type from the input type.
source§

impl From<PlottingError> for BackgroundTaskError

source§

fn from(source: PlottingError) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

§

impl !RefUnwindSafe for BackgroundTaskError

§

impl Send for BackgroundTaskError

§

impl Sync for BackgroundTaskError

§

impl Unpin for BackgroundTaskError

§

impl !UnwindSafe for BackgroundTaskError

Blanket Implementations§

source§

impl<T> Any for T
where +

Trait Implementations§

source§

impl Debug for BackgroundTaskError

source§

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

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

impl Display for BackgroundTaskError

source§

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

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

impl Error for BackgroundTaskError

source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl From<Box<dyn Error + Sync + Send>> for BackgroundTaskError

source§

fn from(source: Box<dyn Error + Send + Sync + 'static>) -> Self

Converts to this type from the input type.
source§

impl From<FarmingError> for BackgroundTaskError

source§

fn from(source: FarmingError) -> Self

Converts to this type from the input type.
source§

impl From<PlottingError> for BackgroundTaskError

source§

fn from(source: PlottingError) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

§

impl !RefUnwindSafe for BackgroundTaskError

§

impl Send for BackgroundTaskError

§

impl Sync for BackgroundTaskError

§

impl Unpin for BackgroundTaskError

§

impl !UnwindSafe for BackgroundTaskError

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<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( diff --git a/subspace_farmer/single_disk_farm/enum.PlottingError.html b/subspace_farmer/single_disk_farm/enum.PlottingError.html index c871ebab9a..57aae3782a 100644 --- a/subspace_farmer/single_disk_farm/enum.PlottingError.html +++ b/subspace_farmer/single_disk_farm/enum.PlottingError.html @@ -29,7 +29,7 @@

§

LowLevel(PlottingError)

Low-level plotting error

§

Io(Error)

I/O error occurred

§

BackgroundDownloadingPanicked

Background downloading panicked

-

Trait Implementations§

source§

impl Debug for PlottingError

source§

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

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

impl Display for PlottingError

source§

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

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

impl Error for PlottingError

source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl From<Error> for PlottingError

source§

fn from(source: Error) -> Self

Converts to this type from the input type.
source§

impl From<PlottingError> for BackgroundTaskError

source§

fn from(source: PlottingError) -> Self

Converts to this type from the input type.
source§

impl From<PlottingError> for PlottingError

source§

fn from(source: PlottingError) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

§

impl !RefUnwindSafe for PlottingError

§

impl Send for PlottingError

§

impl Sync for PlottingError

§

impl Unpin for PlottingError

§

impl !UnwindSafe for PlottingError

Blanket Implementations§

source§

impl<T> Any for T
where +

Trait Implementations§

source§

impl Debug for PlottingError

source§

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

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

impl Display for PlottingError

source§

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

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

impl Error for PlottingError

source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl From<Error> for PlottingError

source§

fn from(source: Error) -> Self

Converts to this type from the input type.
source§

impl From<PlottingError> for BackgroundTaskError

source§

fn from(source: PlottingError) -> Self

Converts to this type from the input type.
source§

impl From<PlottingError> for PlottingError

source§

fn from(source: PlottingError) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

§

impl !RefUnwindSafe for PlottingError

§

impl Send for PlottingError

§

impl Sync for PlottingError

§

impl Unpin for PlottingError

§

impl !UnwindSafe for PlottingError

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<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( diff --git a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmError.html b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmError.html index d557f9741c..a48f9fdb70 100644 --- a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmError.html +++ b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmError.html @@ -58,7 +58,7 @@

§allocated_space: u64

Current allocated space

Allocated space is not enough for one sector

§

FarmTooLarge

Fields

§allocated_space: u64
§allocated_sectors: u64
§max_space: u64
§max_sectors: u16

Farm is too large

-

Trait Implementations§

source§

impl Debug for SingleDiskFarmError

source§

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

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

impl Display for SingleDiskFarmError

source§

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

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

impl Error for SingleDiskFarmError

source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl From<DiskPieceCacheError> for SingleDiskFarmError

source§

fn from(source: DiskPieceCacheError) -> Self

Converts to this type from the input type.
source§

impl From<Error> for SingleDiskFarmError

source§

fn from(source: Error) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

§

impl !RefUnwindSafe for SingleDiskFarmError

§

impl Send for SingleDiskFarmError

§

impl Sync for SingleDiskFarmError

§

impl Unpin for SingleDiskFarmError

§

impl !UnwindSafe for SingleDiskFarmError

Blanket Implementations§

source§

impl<T> Any for T
where +

Trait Implementations§

source§

impl Debug for SingleDiskFarmError

source§

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

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

impl Display for SingleDiskFarmError

source§

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

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

impl Error for SingleDiskFarmError

source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl From<DiskPieceCacheError> for SingleDiskFarmError

source§

fn from(source: DiskPieceCacheError) -> Self

Converts to this type from the input type.
source§

impl From<Error> for SingleDiskFarmError

source§

fn from(source: Error) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

§

impl !RefUnwindSafe for SingleDiskFarmError

§

impl Send for SingleDiskFarmError

§

impl Sync for SingleDiskFarmError

§

impl Unpin for SingleDiskFarmError

§

impl !UnwindSafe for SingleDiskFarmError

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<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( diff --git a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmId.html b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmId.html index c1eaeda6bf..aa50341b84 100644 --- a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmId.html +++ b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmId.html @@ -4,8 +4,8 @@ }
Expand description

An identifier for single disk farm, can be used for in logs, thread names, etc.

Variants§

§

Ulid(Ulid)

Farm ID

Implementations§

source§

impl SingleDiskFarmId

source

pub fn new() -> Self

Creates new ID

-

Trait Implementations§

source§

impl Clone for SingleDiskFarmId

source§

fn clone(&self) -> SingleDiskFarmId

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 SingleDiskFarmId

source§

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

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

impl<'de> Deserialize<'de> for SingleDiskFarmId

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 SingleDiskFarmId

source§

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

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

impl From<Ulid> for SingleDiskFarmId

source§

fn from(original: Ulid) -> SingleDiskFarmId

Converts to this type from the input type.
source§

impl Hash for SingleDiskFarmId

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 +

Trait Implementations§

source§

impl Clone for SingleDiskFarmId

source§

fn clone(&self) -> SingleDiskFarmId

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 SingleDiskFarmId

source§

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

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

impl<'de> Deserialize<'de> for SingleDiskFarmId

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 SingleDiskFarmId

source§

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

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

impl From<Ulid> for SingleDiskFarmId

source§

fn from(original: Ulid) -> SingleDiskFarmId

Converts to this type from the input type.
source§

impl Hash for SingleDiskFarmId

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 Ord for SingleDiskFarmId

source§

fn cmp(&self, other: &SingleDiskFarmId) -> 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 diff --git a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmScrubError.html b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmScrubError.html index 930bf7be05..a8f9c7e33c 100644 --- a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmScrubError.html +++ b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmScrubError.html @@ -100,7 +100,7 @@
§

CacheCantBeOpened

Fields

§file: PathBuf

Cache file

§error: Error

Low-level error

Cache can’t be opened

-

Trait Implementations§

source§

impl Debug for SingleDiskFarmScrubError

source§

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

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

impl Display for SingleDiskFarmScrubError

source§

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

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

impl Error for SingleDiskFarmScrubError

1.30.0 · source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where +

Trait Implementations§

source§

impl Debug for SingleDiskFarmScrubError

source§

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

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

impl Display for SingleDiskFarmScrubError

source§

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

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

impl Error for SingleDiskFarmScrubError

1.30.0 · source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. 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<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( diff --git a/subspace_farmer/single_disk_farm/farming/enum.FarmingError.html b/subspace_farmer/single_disk_farm/farming/enum.FarmingError.html index 8cf280db51..9d562cfefb 100644 --- a/subspace_farmer/single_disk_farm/farming/enum.FarmingError.html +++ b/subspace_farmer/single_disk_farm/farming/enum.FarmingError.html @@ -23,13 +23,13 @@

§

Decoded(DecodedFarmingError)

Decoded farming error

Implementations§

source§

impl FarmingError

source

pub fn str_variant(&self) -> &str

String variant of the error, primarily for monitoring purposes

source

pub fn is_fatal(&self) -> bool

Whether this error is fatal and makes farm unusable

-

Trait Implementations§

source§

impl Debug for FarmingError

source§

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

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

impl Decode for FarmingError

source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.
§

fn decode_into<I>( +

Trait Implementations§

source§

impl Debug for FarmingError

source§

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

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

impl Decode for FarmingError

source§

fn decode<I: Input>(input: &mut I) -> Result<Self, Error>

Attempt to deserialise the value from input.
§

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>
where 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 - 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 Display for FarmingError

source§

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

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

impl Encode for FarmingError

source§

fn encode_to<O: Output + ?Sized>(&self, dest: &mut O)

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

fn size_hint(&self) -> usize

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

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

Convert self to an owned vector.
§

fn using_encoded<R, F>(&self, f: F) -> R
where - 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
source§

impl Error for FarmingError

source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl From<AuditingError> for FarmingError

source§

fn from(source: AuditingError) -> Self

Converts to this type from the input type.
source§

impl From<Error> for FarmingError

source§

fn from(source: Error) -> Self

Converts to this type from the input type.
source§

impl From<FarmingError> for BackgroundTaskError

source§

fn from(source: FarmingError) -> Self

Converts to this type from the input type.
source§

impl From<ProvingError> for FarmingError

source§

fn from(source: ProvingError) -> Self

Converts to this type from the input type.
source§

impl From<ThreadPoolBuildError> for FarmingError

source§

fn from(source: ThreadPoolBuildError) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
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 Display for FarmingError

source§

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

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

impl Encode for FarmingError

source§

fn encode_to<O: Output + ?Sized>(&self, dest: &mut O)

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

fn size_hint(&self) -> usize

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

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

Convert self to an owned vector.
§

fn using_encoded<R, F>(&self, f: F) -> R
where + 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
source§

impl Error for FarmingError

source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl From<AuditingError> for FarmingError

source§

fn from(source: AuditingError) -> Self

Converts to this type from the input type.
source§

impl From<Error> for FarmingError

source§

fn from(source: Error) -> Self

Converts to this type from the input type.
source§

impl From<FarmingError> for BackgroundTaskError

source§

fn from(source: FarmingError) -> Self

Converts to this type from the input type.
source§

impl From<ProvingError> for FarmingError

source§

fn from(source: ProvingError) -> Self

Converts to this type from the input type.
source§

impl From<ThreadPoolBuildError> for FarmingError

source§

fn from(source: ThreadPoolBuildError) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

§

impl !RefUnwindSafe for FarmingError

§

impl Send for FarmingError

§

impl Sync for FarmingError

§

impl Unpin for FarmingError

§

impl !UnwindSafe for FarmingError

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<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( diff --git a/subspace_farmer/single_disk_farm/farming/enum.ProvingResult.html b/subspace_farmer/single_disk_farm/farming/enum.ProvingResult.html index 1d44cd1fa5..40778fe284 100644 --- a/subspace_farmer/single_disk_farm/farming/enum.ProvingResult.html +++ b/subspace_farmer/single_disk_farm/farming/enum.ProvingResult.html @@ -8,14 +8,14 @@

§

Timeout

Proving took too long

§

Rejected

Managed to prove within time limit, but node rejected solution, likely due to timeout on its end

-

Trait Implementations§

source§

impl Clone for ProvingResult

source§

fn clone(&self) -> ProvingResult

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 ProvingResult

source§

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

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

impl Decode for ProvingResult

source§

fn decode<__CodecInputEdqy: Input>( +

Trait Implementations§

source§

impl Clone for ProvingResult

source§

fn clone(&self) -> ProvingResult

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 ProvingResult

source§

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

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

impl Decode for ProvingResult

source§

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

Attempt to deserialise the value from input.
§

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>
where 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 - 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 Display for ProvingResult

source§

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

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

impl Encode for ProvingResult

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 Display for ProvingResult

source§

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

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

impl Encode for ProvingResult

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.
§

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

Convert self to an owned vector.
§

fn using_encoded<R, F>(&self, f: F) -> R
where diff --git a/subspace_farmer/single_disk_farm/farming/struct.DecodedFarmingError.html b/subspace_farmer/single_disk_farm/farming/struct.DecodedFarmingError.html index a6f30ccdb0..ba8e7810b8 100644 --- a/subspace_farmer/single_disk_farm/farming/struct.DecodedFarmingError.html +++ b/subspace_farmer/single_disk_farm/farming/struct.DecodedFarmingError.html @@ -1,13 +1,13 @@ DecodedFarmingError in subspace_farmer::single_disk_farm::farming - Rust

Struct subspace_farmer::single_disk_farm::farming::DecodedFarmingError

source · 
pub struct DecodedFarmingError { /* private fields */ }
Expand description

Special decoded farming error

-

Trait Implementations§

source§

impl Debug for DecodedFarmingError

source§

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

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

impl Decode for DecodedFarmingError

source§

fn decode<__CodecInputEdqy: Input>( +

Trait Implementations§

source§

impl Debug for DecodedFarmingError

source§

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

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

impl Decode for DecodedFarmingError

source§

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

Attempt to deserialise the value from input.
§

fn decode_into<I>( input: &mut I, dst: &mut MaybeUninit<Self> ) -> Result<DecodeFinished, Error>
where 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 - 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 Display for DecodedFarmingError

source§

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

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

impl Encode for DecodedFarmingError

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 Display for DecodedFarmingError

source§

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

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

impl Encode for DecodedFarmingError

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.
§

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

Convert self to an owned vector.
§

fn using_encoded<R, F>(&self, f: F) -> R
where diff --git a/subspace_farmer/single_disk_farm/piece_cache/enum.DiskPieceCacheError.html b/subspace_farmer/single_disk_farm/piece_cache/enum.DiskPieceCacheError.html index 39214fc772..4d808d0a63 100644 --- a/subspace_farmer/single_disk_farm/piece_cache/enum.DiskPieceCacheError.html +++ b/subspace_farmer/single_disk_farm/piece_cache/enum.DiskPieceCacheError.html @@ -16,7 +16,7 @@

Offset outsize of range

§

ZeroCapacity

Cache size has zero capacity, this is not supported

§

ChecksumMismatch

Checksum mismatch

-

Trait Implementations§

source§

impl Debug for DiskPieceCacheError

source§

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

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

impl Display for DiskPieceCacheError

source§

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

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

impl Error for DiskPieceCacheError

source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl From<DiskPieceCacheError> for SingleDiskFarmError

source§

fn from(source: DiskPieceCacheError) -> Self

Converts to this type from the input type.
source§

impl From<Error> for DiskPieceCacheError

source§

fn from(source: Error) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

§

impl !RefUnwindSafe for DiskPieceCacheError

§

impl Send for DiskPieceCacheError

§

impl Sync for DiskPieceCacheError

§

impl Unpin for DiskPieceCacheError

§

impl !UnwindSafe for DiskPieceCacheError

Blanket Implementations§

source§

impl<T> Any for T
where +

Trait Implementations§

source§

impl Debug for DiskPieceCacheError

source§

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

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

impl Display for DiskPieceCacheError

source§

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

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

impl Error for DiskPieceCacheError

source§

fn source(&self) -> Option<&(dyn Error + 'static)>

The lower-level source of this error, if any. Read more
1.0.0 · source§

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()
Read more
1.0.0 · source§

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting
source§

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)
Provides type based access to context intended for error reports. Read more
source§

impl From<DiskPieceCacheError> for SingleDiskFarmError

source§

fn from(source: DiskPieceCacheError) -> Self

Converts to this type from the input type.
source§

impl From<Error> for DiskPieceCacheError

source§

fn from(source: Error) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

§

impl !RefUnwindSafe for DiskPieceCacheError

§

impl Send for DiskPieceCacheError

§

impl Sync for DiskPieceCacheError

§

impl Unpin for DiskPieceCacheError

§

impl !UnwindSafe for DiskPieceCacheError

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<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( diff --git a/subspace_farmer/single_disk_farm/piece_cache/struct.Offset.html b/subspace_farmer/single_disk_farm/piece_cache/struct.Offset.html index cd6db29f09..4a668d29d2 100644 --- a/subspace_farmer/single_disk_farm/piece_cache/struct.Offset.html +++ b/subspace_farmer/single_disk_farm/piece_cache/struct.Offset.html @@ -1,6 +1,6 @@ Offset in subspace_farmer::single_disk_farm::piece_cache - Rust

Struct subspace_farmer::single_disk_farm::piece_cache::Offset

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

Offset wrapper for pieces in DiskPieceCache

-

Trait Implementations§

source§

impl Clone for Offset

source§

fn clone(&self) -> Offset

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 Offset

source§

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

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

impl Display for Offset

source§

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

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

impl Copy for Offset

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where +

Trait Implementations§

source§

impl Clone for Offset

source§

fn clone(&self) -> Offset

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 Offset

source§

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

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

impl Display for Offset

source§

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

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

impl Copy for Offset

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<'a, T, E> AsTaggedExplicit<'a, E> for T
where T: 'a,

§

fn explicit(self, class: Class, tag: u32) -> TaggedParser<'a, Explicit, Self, E>

§

impl<'a, T, E> AsTaggedImplicit<'a, E> for T
where T: 'a,

§

fn implicit( diff --git a/subspace_farmer/utils/fn.all_cpu_cores.html b/subspace_farmer/utils/fn.all_cpu_cores.html index 4e00ebe7d3..745c5180a0 100644 --- a/subspace_farmer/utils/fn.all_cpu_cores.html +++ b/subspace_farmer/utils/fn.all_cpu_cores.html @@ -1,5 +1,5 @@ all_cpu_cores in subspace_farmer::utils - Rust
-

Function subspace_farmer::utils::all_cpu_cores

source · 
pub fn all_cpu_cores() -> Vec<CpuCoreSet>
Expand description

Get all cpu cores, grouped into sets according to NUMA nodes or L3 cache groups on large CPUs.

+

Function subspace_farmer::utils::all_cpu_cores

source · 
pub fn all_cpu_cores() -> Vec<CpuCoreSet>
Expand description

Get all cpu cores, grouped into sets according to NUMA nodes or L3 cache groups on large CPUs.

Returned vector is guaranteed to have at least one element and have non-zero number of CPU cores in each set.

\ No newline at end of file diff --git a/subspace_farmer/utils/fn.create_plotting_thread_pool_manager.html b/subspace_farmer/utils/fn.create_plotting_thread_pool_manager.html index cc630ddb3e..0e0a1d8c08 100644 --- a/subspace_farmer/utils/fn.create_plotting_thread_pool_manager.html +++ b/subspace_farmer/utils/fn.create_plotting_thread_pool_manager.html @@ -1,5 +1,5 @@ create_plotting_thread_pool_manager in subspace_farmer::utils - Rust
-

Function subspace_farmer::utils::create_plotting_thread_pool_manager

source · 
pub fn create_plotting_thread_pool_manager<I>(
+    
Function subspace_farmer::utils::create_plotting_thread_pool_manager
source · 
pub fn create_plotting_thread_pool_manager<I>(
     cpu_core_sets: I
 ) -> Result<PlottingThreadPoolManager, ThreadPoolBuildError>
where
     I: ExactSizeIterator<Item = (CpuCoreSet, CpuCoreSet)>,
Expand description
Creates thread pool pairs for each of CPU core set pair with number of plotting and replotting threads corresponding
diff --git a/subspace_farmer/utils/fn.parse_cpu_cores_sets.html b/subspace_farmer/utils/fn.parse_cpu_cores_sets.html
index 71aad2e2dc..abc995e2ca 100644
--- a/subspace_farmer/utils/fn.parse_cpu_cores_sets.html
+++ b/subspace_farmer/utils/fn.parse_cpu_cores_sets.html
@@ -1,4 +1,4 @@
 parse_cpu_cores_sets in subspace_farmer::utils - Rust

-    
Function subspace_farmer::utils::parse_cpu_cores_sets
source · 
pub fn parse_cpu_cores_sets(s: &str) -> Result<Vec<CpuCoreSet>, ParseIntError>
Expand description
Parse space-separated set of groups of CPU cores (individual cores are coma-separated) into
+    
Function subspace_farmer::utils::parse_cpu_cores_sets
source · 
pub fn parse_cpu_cores_sets(s: &str) -> Result<Vec<CpuCoreSet>, ParseIntError>
Expand description
Parse space-separated set of groups of CPU cores (individual cores are coma-separated) into
 vector of CPU core sets that can be used for creation of plotting/replotting thread pools.

 

\ No newline at end of file
diff --git a/subspace_farmer/utils/fn.rayon_custom_spawn_handler.html b/subspace_farmer/utils/fn.rayon_custom_spawn_handler.html
index 0270802738..410e7cb147 100644
--- a/subspace_farmer/utils/fn.rayon_custom_spawn_handler.html
+++ b/subspace_farmer/utils/fn.rayon_custom_spawn_handler.html
@@ -1,5 +1,5 @@
 rayon_custom_spawn_handler in subspace_farmer::utils - Rust

-    
Function subspace_farmer::utils::rayon_custom_spawn_handler
source · 
pub fn rayon_custom_spawn_handler<SpawnHandlerBuilder, SpawnHandler, SpawnHandlerResult>(
+    
Function subspace_farmer::utils::rayon_custom_spawn_handler
source · 
pub fn rayon_custom_spawn_handler<SpawnHandlerBuilder, SpawnHandler, SpawnHandlerResult>(
     spawn_handler_builder: SpawnHandlerBuilder
 ) -> impl FnMut(ThreadBuilder) -> Result<()>
where
     SpawnHandlerBuilder: FnMut(ThreadBuilder) -> SpawnHandler + Clone,
diff --git a/subspace_farmer/utils/fn.recommended_number_of_farming_threads.html b/subspace_farmer/utils/fn.recommended_number_of_farming_threads.html
index aafc0d0276..a0ebc186af 100644
--- a/subspace_farmer/utils/fn.recommended_number_of_farming_threads.html
+++ b/subspace_farmer/utils/fn.recommended_number_of_farming_threads.html
@@ -1,4 +1,4 @@
 recommended_number_of_farming_threads in subspace_farmer::utils - Rust

-    
Function subspace_farmer::utils::recommended_number_of_farming_threads
source · 
pub fn recommended_number_of_farming_threads() -> usize
Expand description
Recommended number of thread pool size for farming, equal to number of CPU cores in the first
+    
Function subspace_farmer::utils::recommended_number_of_farming_threads
source · 
pub fn recommended_number_of_farming_threads() -> usize
Expand description
Recommended number of thread pool size for farming, equal to number of CPU cores in the first
 NUMA node

 

\ No newline at end of file
diff --git a/subspace_farmer/utils/fn.run_future_in_dedicated_thread.html b/subspace_farmer/utils/fn.run_future_in_dedicated_thread.html
index 62e7354140..36371e872a 100644
--- a/subspace_farmer/utils/fn.run_future_in_dedicated_thread.html
+++ b/subspace_farmer/utils/fn.run_future_in_dedicated_thread.html
@@ -1,5 +1,5 @@
 run_future_in_dedicated_thread in subspace_farmer::utils - Rust

-    
Function subspace_farmer::utils::run_future_in_dedicated_thread
source · 
pub fn run_future_in_dedicated_thread<CreateFut, Fut, T>(
+    
Function subspace_farmer::utils::run_future_in_dedicated_thread
source · 
pub fn run_future_in_dedicated_thread<CreateFut, Fut, T>(
     create_future: CreateFut,
     thread_name: String
 ) -> Result<impl Future<Output = Result<T, Canceled>> + Send>
where
diff --git a/subspace_farmer/utils/fn.thread_pool_core_indices.html b/subspace_farmer/utils/fn.thread_pool_core_indices.html
index 12e3f6b2eb..adca2160e7 100644
--- a/subspace_farmer/utils/fn.thread_pool_core_indices.html
+++ b/subspace_farmer/utils/fn.thread_pool_core_indices.html
@@ -1,5 +1,5 @@
 thread_pool_core_indices in subspace_farmer::utils - Rust

-    
Function subspace_farmer::utils::thread_pool_core_indices
source · 
pub fn thread_pool_core_indices(
+    
Function subspace_farmer::utils::thread_pool_core_indices
source · 
pub fn thread_pool_core_indices(
     thread_pool_size: Option<NonZeroUsize>,
     thread_pools: Option<NonZeroUsize>
 ) -> Vec<CpuCoreSet>
Expand description
Thread indices for each thread pool

diff --git a/subspace_farmer/utils/fn.tokio_rayon_spawn_handler.html b/subspace_farmer/utils/fn.tokio_rayon_spawn_handler.html
index 8eec1f2741..f6e2888cc8 100644
--- a/subspace_farmer/utils/fn.tokio_rayon_spawn_handler.html
+++ b/subspace_farmer/utils/fn.tokio_rayon_spawn_handler.html
@@ -1,4 +1,4 @@
 tokio_rayon_spawn_handler in subspace_farmer::utils - Rust

-    
Function subspace_farmer::utils::tokio_rayon_spawn_handler
source · 
pub fn tokio_rayon_spawn_handler() -> impl FnMut(ThreadBuilder) -> Result<()>
Expand description
This function is supposed to be used with [rayon::ThreadPoolBuilder::spawn_handler()] to
+    
Function subspace_farmer::utils::tokio_rayon_spawn_handler
source · 
pub fn tokio_rayon_spawn_handler() -> impl FnMut(ThreadBuilder) -> Result<()>
Expand description
This function is supposed to be used with [rayon::ThreadPoolBuilder::spawn_handler()] to
 inherit current tokio runtime.

 

\ No newline at end of file
diff --git a/subspace_farmer/utils/index.html b/subspace_farmer/utils/index.html
index 80d40a8574..6b456f6db9 100644
--- a/subspace_farmer/utils/index.html
+++ b/subspace_farmer/utils/index.html
@@ -1,5 +1,5 @@
 subspace_farmer::utils - Rust

-    
Module subspace_farmer::utils
source · 
Modules

\ No newline at end of file
+    PosTable: Table,

\ No newline at end of file
diff --git a/subspace_farmer_components/plotting/fn.plot_sector.html b/subspace_farmer_components/plotting/fn.plot_sector.html
index 1ec8c0e6b4..8883132944 100644
--- a/subspace_farmer_components/plotting/fn.plot_sector.html
+++ b/subspace_farmer_components/plotting/fn.plot_sector.html
@@ -2,7 +2,7 @@
     
Function subspace_farmer_components::plotting::plot_sector
source · 
pub async fn plot_sector<PosTable, PG>(
     options: PlotSectorOptions<'_, PosTable, PG>
 ) -> Result<PlottedSector, PlottingError>
where
-    PosTable: Table,
+    PosTable: Table,
     PG: PieceGetter,
Expand description
Plot a single sector.

 
This is a convenient wrapper around download_sector and encode_sector functions.

 
NOTE: Even though this function is async, it has blocking code inside and must be running in a
diff --git a/subspace_farmer_components/plotting/struct.DownloadSectorOptions.html b/subspace_farmer_components/plotting/struct.DownloadSectorOptions.html
index 089016ab20..aa78808053 100644
--- a/subspace_farmer_components/plotting/struct.DownloadSectorOptions.html
+++ b/subspace_farmer_components/plotting/struct.DownloadSectorOptions.html
@@ -1,19 +1,19 @@
 DownloadSectorOptions in subspace_farmer_components::plotting - Rust

     
Struct subspace_farmer_components::plotting::DownloadSectorOptions
source · 
pub struct DownloadSectorOptions<'a, PG> {
-    pub public_key: &'a PublicKey,
-    pub sector_index: SectorIndex,
+    pub public_key: &'a PublicKey,
+    pub sector_index: SectorIndex,
     pub piece_getter: &'a PG,
     pub piece_getter_retry_policy: PieceGetterRetryPolicy,
     pub farmer_protocol_info: FarmerProtocolInfo,
-    pub kzg: &'a Kzg,
+    pub kzg: &'a Kzg,
     pub pieces_in_sector: u16,
 }
Expand description
Options for sector downloading

-
Fields§
§public_key: &'a PublicKey
Public key corresponding to sector

-
§sector_index: SectorIndex
Sector index

+
Fields§
§public_key: &'a PublicKey
Public key corresponding to sector

+
§sector_index: SectorIndex
Sector index

 
§piece_getter: &'a PG
Getter for pieces of archival history

 
§piece_getter_retry_policy: PieceGetterRetryPolicy
Retry policy for piece getter

 
§farmer_protocol_info: FarmerProtocolInfo
Farmer protocol info

-
§kzg: &'a Kzg
KZG instance

+
§kzg: &'a Kzg
KZG instance

 
§pieces_in_sector: u16
How many pieces should sector contain

 
Auto Trait Implementations§
§
impl<'a, PG> !RefUnwindSafe for DownloadSectorOptions<'a, PG>
§
impl<'a, PG> Send for DownloadSectorOptions<'a, PG>
where
     PG: Sync,
§
impl<'a, PG> Sync for DownloadSectorOptions<'a, PG>
where
diff --git a/subspace_farmer_components/plotting/struct.EncodeSectorOptions.html b/subspace_farmer_components/plotting/struct.EncodeSectorOptions.html
index 6680fb1f84..7fd5d7693e 100644
--- a/subspace_farmer_components/plotting/struct.EncodeSectorOptions.html
+++ b/subspace_farmer_components/plotting/struct.EncodeSectorOptions.html
@@ -1,27 +1,27 @@
 EncodeSectorOptions in subspace_farmer_components::plotting - Rust

     
Struct subspace_farmer_components::plotting::EncodeSectorOptions
source · 
pub struct EncodeSectorOptions<'a, PosTable>
where
-    PosTable: Table,
{
-    pub sector_index: SectorIndex,
+    PosTable: Table,
{
+    pub sector_index: SectorIndex,
     pub erasure_coding: &'a ErasureCoding,
     pub pieces_in_sector: u16,
     pub sector_output: &'a mut Vec<u8>,
     pub sector_metadata_output: &'a mut Vec<u8>,
-    pub table_generator: &'a mut PosTable::Generator,
+    pub table_generator: &'a mut PosTable::Generator,
 }
Expand description
Options for encoding a sector.

 
Sector output and sector metadata output should be either empty (in which case they’ll be
 resized to correct size automatically) or correctly sized from the beginning or else error will
 be returned.

-
Fields§
§sector_index: SectorIndex
Sector index

+
Fields§
§sector_index: SectorIndex
Sector index

 
§erasure_coding: &'a ErasureCoding
Erasure coding instance

 
§pieces_in_sector: u16
How many pieces should sector contain

 
§sector_output: &'a mut Vec<u8>
Where plotted sector should be written, vector must either be empty (in which case it’ll be
 resized to correct size automatically) or correctly sized from the beginning

 
§sector_metadata_output: &'a mut Vec<u8>
Where plotted sector metadata should be written, vector must either be empty (in which case
 it’ll be resized to correct size automatically) or correctly sized from the beginning

-
§table_generator: &'a mut PosTable::Generator
Proof of space table generator

+
§table_generator: &'a mut PosTable::Generator
Proof of space table generator

 
Auto Trait Implementations§
§
impl<'a, PosTable> RefUnwindSafe for EncodeSectorOptions<'a, PosTable>
where
-    <PosTable as Table>::Generator: RefUnwindSafe,
§
impl<'a, PosTable> Send for EncodeSectorOptions<'a, PosTable>
§
impl<'a, PosTable> Sync for EncodeSectorOptions<'a, PosTable>
where
-    <PosTable as Table>::Generator: Sync,
§
impl<'a, PosTable> Unpin for EncodeSectorOptions<'a, PosTable>
§
impl<'a, PosTable> !UnwindSafe for EncodeSectorOptions<'a, PosTable>
Blanket Implementations§
source§
impl<T> Any for T
where
+    <PosTable as Table>::Generator: RefUnwindSafe,
§
impl<'a, PosTable> Send for EncodeSectorOptions<'a, PosTable>
§
impl<'a, PosTable> Sync for EncodeSectorOptions<'a, PosTable>
where
+    <PosTable as Table>::Generator: Sync,
§
impl<'a, PosTable> Unpin for EncodeSectorOptions<'a, PosTable>
§
impl<'a, PosTable> !UnwindSafe for EncodeSectorOptions<'a, PosTable>
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> Conv for T
§
fn conv<T>(self) -> T
where
diff --git a/subspace_farmer_components/plotting/struct.PlotSectorOptions.html b/subspace_farmer_components/plotting/struct.PlotSectorOptions.html
index 572283349f..b3dc797505 100644
--- a/subspace_farmer_components/plotting/struct.PlotSectorOptions.html
+++ b/subspace_farmer_components/plotting/struct.PlotSectorOptions.html
@@ -1,29 +1,29 @@
 PlotSectorOptions in subspace_farmer_components::plotting - Rust

     
Struct subspace_farmer_components::plotting::PlotSectorOptions
source · 
pub struct PlotSectorOptions<'a, PosTable, PG>
where
-    PosTable: Table,
{
Show 13 fields
-    pub public_key: &'a PublicKey,
-    pub sector_index: SectorIndex,
+    PosTable: Table,
{
Show 13 fields
+    pub public_key: &'a PublicKey,
+    pub sector_index: SectorIndex,
     pub piece_getter: &'a PG,
     pub piece_getter_retry_policy: PieceGetterRetryPolicy,
     pub farmer_protocol_info: FarmerProtocolInfo,
-    pub kzg: &'a Kzg,
+    pub kzg: &'a Kzg,
     pub erasure_coding: &'a ErasureCoding,
     pub pieces_in_sector: u16,
     pub sector_output: &'a mut Vec<u8>,
     pub sector_metadata_output: &'a mut Vec<u8>,
     pub downloading_semaphore: Option<Arc<Semaphore>>,
     pub encoding_semaphore: Option<&'a Semaphore>,
-    pub table_generator: &'a mut PosTable::Generator,
+    pub table_generator: &'a mut PosTable::Generator,
 
}
Expand description
Options for plotting a sector.

 
Sector output and sector metadata output should be either empty (in which case they’ll be
 resized to correct size automatically) or correctly sized from the beginning or else error will
 be returned.

-
Fields§
§public_key: &'a PublicKey
Public key corresponding to sector

-
§sector_index: SectorIndex
Sector index

+
Fields§
§public_key: &'a PublicKey
Public key corresponding to sector

+
§sector_index: SectorIndex
Sector index

 
§piece_getter: &'a PG
Getter for pieces of archival history

 
§piece_getter_retry_policy: PieceGetterRetryPolicy
Retry policy for piece getter

 
§farmer_protocol_info: FarmerProtocolInfo
Farmer protocol info

-
§kzg: &'a Kzg
KZG instance

+
§kzg: &'a Kzg
KZG instance

 
§erasure_coding: &'a ErasureCoding
Erasure coding instance

 
§pieces_in_sector: u16
How many pieces should sector contain

 
§sector_output: &'a mut Vec<u8>
Where plotted sector should be written, vector must either be empty (in which case it’ll be
@@ -34,11 +34,11 @@
 usage of the plotting process, permit will be held until the end of the plotting process

 
§encoding_semaphore: Option<&'a Semaphore>
Semaphore for part of the plotting when farmer encodes downloaded sector, should typically
 allow one permit at a time for efficient CPU utilization

-
§table_generator: &'a mut PosTable::Generator
Proof of space table generator

+
§table_generator: &'a mut PosTable::Generator
Proof of space table generator

 
Auto Trait Implementations§
§
impl<'a, PosTable, PG> !RefUnwindSafe for PlotSectorOptions<'a, PosTable, PG>
§
impl<'a, PosTable, PG> Send for PlotSectorOptions<'a, PosTable, PG>
where
     PG: Sync,
§
impl<'a, PosTable, PG> Sync for PlotSectorOptions<'a, PosTable, PG>
where
     PG: Sync,
-    <PosTable as Table>::Generator: Sync,
§
impl<'a, PosTable, PG> Unpin for PlotSectorOptions<'a, PosTable, PG>
§
impl<'a, PosTable, PG> !UnwindSafe for PlotSectorOptions<'a, PosTable, PG>
Blanket Implementations§
source§
impl<T> Any for T
where
+    <PosTable as Table>::Generator: Sync,
§
impl<'a, PosTable, PG> Unpin for PlotSectorOptions<'a, PosTable, PG>
§
impl<'a, PosTable, PG> !UnwindSafe for PlotSectorOptions<'a, PosTable, PG>
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> Conv for T
§
fn conv<T>(self) -> T
where
diff --git a/subspace_farmer_components/plotting/struct.PlottedSector.html b/subspace_farmer_components/plotting/struct.PlottedSector.html
index 4e4313e5da..32956d253a 100644
--- a/subspace_farmer_components/plotting/struct.PlottedSector.html
+++ b/subspace_farmer_components/plotting/struct.PlottedSector.html
@@ -1,14 +1,14 @@
 PlottedSector in subspace_farmer_components::plotting - Rust

     
Struct subspace_farmer_components::plotting::PlottedSector
source · 
pub struct PlottedSector {
-    pub sector_id: SectorId,
-    pub sector_index: SectorIndex,
+    pub sector_id: SectorId,
+    pub sector_index: SectorIndex,
     pub sector_metadata: SectorMetadataChecksummed,
-    pub piece_indexes: Vec<PieceIndex>,
+    pub piece_indexes: Vec<PieceIndex>,
 }
Expand description
Information about sector that was plotted

-
Fields§
§sector_id: SectorId
Sector ID

-
§sector_index: SectorIndex
Sector index

+
Fields§
§sector_id: SectorId
Sector ID

+
§sector_index: SectorIndex
Sector index

 
§sector_metadata: SectorMetadataChecksummed
Sector metadata

-
§piece_indexes: Vec<PieceIndex>
Indexes of pieces that were plotted

+
§piece_indexes: Vec<PieceIndex>
Indexes of pieces that were plotted

 
Trait Implementations§
source§
impl Clone for PlottedSector
source§
fn clone(&self) -> PlottedSector
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 PlottedSector
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Decode for PlottedSector
source§
fn decode<__CodecInputEdqy: Input>(
     __codec_input_edqy: &mut __CodecInputEdqy
 ) -> Result<Self, Error>
Attempt to deserialise the value from input.
§
fn decode_into<I>(
diff --git a/subspace_farmer_components/plotting/trait.PieceGetter.html b/subspace_farmer_components/plotting/trait.PieceGetter.html
index 63d8ce37a2..77401a0626 100644
--- a/subspace_farmer_components/plotting/trait.PieceGetter.html
+++ b/subspace_farmer_components/plotting/trait.PieceGetter.html
@@ -3,30 +3,30 @@
     // Required method
     fn get_piece<'life0, 'async_trait>(
         &'life0 self,
-        piece_index: PieceIndex,
+        piece_index: PieceIndex,
         retry_policy: PieceGetterRetryPolicy
-    ) -> Pin<Box<dyn Future<Output = Result<Option<Piece>, Box<dyn Error + Send + Sync + 'static>>> + Send + 'async_trait>>
+    ) -> Pin<Box<dyn Future<Output = Result<Option<Piece>, Box<dyn Error + Send + Sync + 'static>>> + Send + 'async_trait>>
        where Self: 'async_trait,
              'life0: 'async_trait;
 }
Expand description

Duplicate trait for the subspace_networking::PieceReceiver. The goal of this trait is simplifying dependency graph.

Required Methods§

source

fn get_piece<'life0, 'async_trait>( &'life0 self, - piece_index: PieceIndex, + piece_index: PieceIndex, retry_policy: PieceGetterRetryPolicy -) -> Pin<Box<dyn Future<Output = Result<Option<Piece>, Box<dyn Error + Send + Sync + 'static>>> + Send + 'async_trait>>
where +) -> Pin<Box<dyn Future<Output = Result<Option<Piece>, Box<dyn Error + Send + Sync + 'static>>> + Send + 'async_trait>>
where Self: 'async_trait, - 'life0: 'async_trait,

Implementations on Foreign Types§

source§

impl PieceGetter for ArchivedHistorySegment

source§

fn get_piece<'life0, 'async_trait>( + 'life0: 'async_trait,

Implementations on Foreign Types§

source§

impl PieceGetter for ArchivedHistorySegment

source§

fn get_piece<'life0, 'async_trait>( &'life0 self, - piece_index: PieceIndex, + piece_index: PieceIndex, _retry_policy: PieceGetterRetryPolicy -) -> Pin<Box<dyn Future<Output = Result<Option<Piece>, Box<dyn Error + Send + Sync + 'static>>> + Send + 'async_trait>>
where +) -> Pin<Box<dyn Future<Output = Result<Option<Piece>, Box<dyn Error + Send + Sync + 'static>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

source§

impl<T> PieceGetter for Arc<T>
where T: PieceGetter + Send + Sync,

source§

fn get_piece<'life0, 'async_trait>( &'life0 self, - piece_index: PieceIndex, + piece_index: PieceIndex, retry_policy: PieceGetterRetryPolicy -) -> Pin<Box<dyn Future<Output = Result<Option<Piece>, Box<dyn Error + Send + Sync + 'static>>> + Send + 'async_trait>>
where +) -> Pin<Box<dyn Future<Output = Result<Option<Piece>, Box<dyn Error + Send + Sync + 'static>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Implementors§

\ No newline at end of file diff --git a/subspace_farmer_components/proving/enum.ProvingError.html b/subspace_farmer_components/proving/enum.ProvingError.html index 7b2fda912b..01e663c194 100644 --- a/subspace_farmer_components/proving/enum.ProvingError.html +++ b/subspace_farmer_components/proving/enum.ProvingError.html @@ -2,11 +2,11 @@

Enum subspace_farmer_components::proving::ProvingError

source · 
pub enum ProvingError {
     InvalidErasureCodingInstance,
     FailedToCreatePolynomialForRecord {
-        piece_offset: PieceOffset,
+        piece_offset: PieceOffset,
         error: String,
     },
     FailedToCreateChunkWitness {
-        piece_offset: PieceOffset,
+        piece_offset: PieceOffset,
         chunk_offset: u32,
         error: String,
     },
@@ -15,10 +15,10 @@
     RecordReadingError(ReadingError),
 }
Expand description

Errors that happen during proving

Variants§

§

InvalidErasureCodingInstance

Invalid erasure coding instance

-
§

FailedToCreatePolynomialForRecord

Fields

§piece_offset: PieceOffset

Piece offset

+
§

FailedToCreatePolynomialForRecord

Fields

§piece_offset: PieceOffset

Piece offset

§error: String

Lower-level error

Failed to create polynomial for record

-
§

FailedToCreateChunkWitness

Fields

§piece_offset: PieceOffset

Piece offset

+
§

FailedToCreateChunkWitness

Fields

§piece_offset: PieceOffset

Piece offset

§chunk_offset: u32

Chunk index

§error: String

Lower-level error

Failed to create chunk witness

diff --git a/subspace_farmer_components/proving/struct.SolutionCandidates.html b/subspace_farmer_components/proving/struct.SolutionCandidates.html index ee4453f209..aab984a92f 100644 --- a/subspace_farmer_components/proving/struct.SolutionCandidates.html +++ b/subspace_farmer_components/proving/struct.SolutionCandidates.html @@ -7,13 +7,13 @@

source

pub fn into_solutions<RewardAddress, PosTable, TableGenerator>( self, reward_address: &'a RewardAddress, - kzg: &'a Kzg, + kzg: &'a Kzg, erasure_coding: &'a ErasureCoding, table_generator: TableGenerator -) -> Result<impl ProvableSolutions<Item = Result<Solution<PublicKey, RewardAddress>, ProvingError>> + 'a, ProvingError>
where +) -> Result<impl ProvableSolutions<Item = Result<Solution<PublicKey, RewardAddress>, ProvingError>> + 'a, ProvingError>
where RewardAddress: Copy, - PosTable: Table, - TableGenerator: FnMut(&PosSeed) -> PosTable + 'a,

Turn solution candidates into actual solutions

+ PosTable: Table, + TableGenerator: FnMut(&PosSeed) -> PosTable + 'a,

Turn solution candidates into actual solutions

Trait Implementations§

source§

impl<'a, Sector> Clone for SolutionCandidates<'a, Sector>
where Sector: Clone + 'a,

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<'a, Sector> Debug for SolutionCandidates<'a, Sector>
where Sector: 'a + Debug,

source§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

§

impl<'a, Sector> RefUnwindSafe for SolutionCandidates<'a, Sector>
where diff --git a/subspace_farmer_components/proving/trait.ProvableSolutions.html b/subspace_farmer_components/proving/trait.ProvableSolutions.html index 3bfa50ba75..8617391fd0 100644 --- a/subspace_farmer_components/proving/trait.ProvableSolutions.html +++ b/subspace_farmer_components/proving/trait.ProvableSolutions.html @@ -1,7 +1,7 @@ ProvableSolutions in subspace_farmer_components::proving - Rust

Trait subspace_farmer_components::proving::ProvableSolutions

source · 
pub trait ProvableSolutions: ExactSizeIterator {
     // Required method
-    fn best_solution_distance(&self) -> Option<SolutionRange>;
+    fn best_solution_distance(&self) -> Option<SolutionRange>;
 }
Expand description

Solutions that can be proven if necessary.

-

Required Methods§

source

fn best_solution_distance(&self) -> Option<SolutionRange>

Best solution distance found, None in case there are no solutions

+

Required Methods§

source

fn best_solution_distance(&self) -> Option<SolutionRange>

Best solution distance found, None in case there are no solutions

Implementors§

\ No newline at end of file diff --git a/subspace_farmer_components/reading/enum.ReadingError.html b/subspace_farmer_components/reading/enum.ReadingError.html index c7fbe78ed7..e42d288af9 100644 --- a/subspace_farmer_components/reading/enum.ReadingError.html +++ b/subspace_farmer_components/reading/enum.ReadingError.html @@ -5,13 +5,13 @@ error: Error, }, InvalidChunk { - s_bucket: SBucket, + s_bucket: SBucket, encoded_chunk_used: bool, chunk_location: usize, error: String, }, FailedToErasureDecodeRecord { - piece_offset: PieceOffset, + piece_offset: PieceOffset, error: String, }, WrongRecordSizeAfterDecoding { @@ -27,12 +27,12 @@

Failed to read chunk.

This is an implementation bug, most likely due to mismatch between sector contents map and other farming parameters.

-
§

InvalidChunk

Fields

§s_bucket: SBucket

S-bucket

+
§

InvalidChunk

Fields

§s_bucket: SBucket

S-bucket

§encoded_chunk_used: bool

Indicates whether chunk was encoded

§chunk_location: usize

Chunk location

§error: String

Lower-level error

Invalid chunk, possible disk corruption

-
§

FailedToErasureDecodeRecord

Fields

§piece_offset: PieceOffset

Piece offset

+
§

FailedToErasureDecodeRecord

Fields

§piece_offset: PieceOffset

Piece offset

§error: String

Lower-level error

Failed to erasure-decode record

§

WrongRecordSizeAfterDecoding

Fields

§expected: usize

Expected size in bytes

diff --git a/subspace_farmer_components/reading/fn.read_piece.html b/subspace_farmer_components/reading/fn.read_piece.html index caa6025e6e..7ed5840a56 100644 --- a/subspace_farmer_components/reading/fn.read_piece.html +++ b/subspace_farmer_components/reading/fn.read_piece.html @@ -1,13 +1,13 @@ read_piece in subspace_farmer_components::reading - Rust

Function subspace_farmer_components::reading::read_piece

source · 
pub async fn read_piece<PosTable, S, A>(
-    piece_offset: PieceOffset,
-    sector_id: &SectorId,
+    piece_offset: PieceOffset,
+    sector_id: &SectorId,
     sector_metadata: &SectorMetadataChecksummed,
     sector: &ReadAt<S, A>,
     erasure_coding: &ErasureCoding,
-    table_generator: &mut PosTable::Generator
-) -> Result<Piece, ReadingError>
where
-    PosTable: Table,
+    table_generator: &mut PosTable::Generator
+) -> Result<Piece, ReadingError>
where
+    PosTable: Table,
     S: ReadAtSync,
     A: ReadAtAsync,
Expand description

Read piece from sector.

NOTE: Even though this function is async, proof of time table generation is expensive and should diff --git a/subspace_farmer_components/reading/fn.read_sector_record_chunks.html b/subspace_farmer_components/reading/fn.read_sector_record_chunks.html index 95f12a3edc..06c817fb26 100644 --- a/subspace_farmer_components/reading/fn.read_sector_record_chunks.html +++ b/subspace_farmer_components/reading/fn.read_sector_record_chunks.html @@ -1,13 +1,13 @@ read_sector_record_chunks in subspace_farmer_components::reading - Rust

Function subspace_farmer_components::reading::read_sector_record_chunks

source · 
pub async fn read_sector_record_chunks<PosTable, S, A>(
-    piece_offset: PieceOffset,
+    piece_offset: PieceOffset,
     pieces_in_sector: u16,
     s_bucket_offsets: &[u32; 65536],
     sector_contents_map: &SectorContentsMap,
     pos_table: &PosTable,
     sector: &ReadAt<S, A>
-) -> Result<Box<[Option<Scalar>; 65536]>, ReadingError>
where
-    PosTable: Table,
+) -> Result<Box<[Option<Scalar>; 65536]>, ReadingError>
where
+    PosTable: Table,
     S: ReadAtSync,
     A: ReadAtAsync,
Expand description

Read sector record chunks, only plotted s-buckets are returned (in decoded form).

NOTE: This is an async function, but it also does CPU-intensive operation internally, while it diff --git a/subspace_farmer_components/reading/fn.recover_extended_record_chunks.html b/subspace_farmer_components/reading/fn.recover_extended_record_chunks.html index d629f7a85c..da41529e0a 100644 --- a/subspace_farmer_components/reading/fn.recover_extended_record_chunks.html +++ b/subspace_farmer_components/reading/fn.recover_extended_record_chunks.html @@ -1,7 +1,7 @@ recover_extended_record_chunks in subspace_farmer_components::reading - Rust

Function subspace_farmer_components::reading::recover_extended_record_chunks

source · 
pub fn recover_extended_record_chunks(
-    sector_record_chunks: &[Option<Scalar>; 65536],
-    piece_offset: PieceOffset,
+    sector_record_chunks: &[Option<Scalar>; 65536],
+    piece_offset: PieceOffset,
     erasure_coding: &ErasureCoding
-) -> Result<Box<[Scalar; 65536]>, ReadingError>
Expand description

Given sector record chunks recover extended record chunks (both source and parity)

+) -> Result<Box<[Scalar; 65536]>, ReadingError>
Expand description

Given sector record chunks recover extended record chunks (both source and parity)

\ No newline at end of file diff --git a/subspace_farmer_components/reading/fn.recover_source_record_chunks.html b/subspace_farmer_components/reading/fn.recover_source_record_chunks.html index 7c1e4afd37..b125ccf5da 100644 --- a/subspace_farmer_components/reading/fn.recover_source_record_chunks.html +++ b/subspace_farmer_components/reading/fn.recover_source_record_chunks.html @@ -1,7 +1,7 @@ recover_source_record_chunks in subspace_farmer_components::reading - Rust

Function subspace_farmer_components::reading::recover_source_record_chunks

source · 
pub fn recover_source_record_chunks(
-    sector_record_chunks: &[Option<Scalar>; 65536],
-    piece_offset: PieceOffset,
+    sector_record_chunks: &[Option<Scalar>; 65536],
+    piece_offset: PieceOffset,
     erasure_coding: &ErasureCoding
-) -> Result<impl ExactSizeIterator<Item = Scalar>, ReadingError>
Expand description

Given sector record chunks recover source record chunks in form of an iterator.

+) -> Result<impl ExactSizeIterator<Item = Scalar>, ReadingError>
Expand description

Given sector record chunks recover source record chunks in form of an iterator.

\ No newline at end of file diff --git a/subspace_farmer_components/reading/struct.PlotRecord.html b/subspace_farmer_components/reading/struct.PlotRecord.html index 3247fc7559..c70ba25235 100644 --- a/subspace_farmer_components/reading/struct.PlotRecord.html +++ b/subspace_farmer_components/reading/struct.PlotRecord.html @@ -1,12 +1,12 @@ PlotRecord in subspace_farmer_components::reading - Rust

Struct subspace_farmer_components::reading::PlotRecord

source · 
pub struct PlotRecord {
-    pub scalars: Box<[Scalar; 32768]>,
-    pub commitment: RecordCommitment,
-    pub witness: RecordWitness,
+    pub scalars: Box<[Scalar; 32768]>,
+    pub commitment: RecordCommitment,
+    pub witness: RecordWitness,
 }
Expand description

Record contained in the plot

-

Fields§

§scalars: Box<[Scalar; 32768]>

Record scalars

-
§commitment: RecordCommitment

Record commitment

-
§witness: RecordWitness

Record witness

+

Fields§

§scalars: Box<[Scalar; 32768]>

Record scalars

+
§commitment: RecordCommitment

Record commitment

+
§witness: RecordWitness

Record witness

Trait Implementations§

source§

impl Clone for PlotRecord

source§

fn clone(&self) -> PlotRecord

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 PlotRecord

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
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 diff --git a/subspace_farmer_components/sector/struct.SectorContentsMap.html b/subspace_farmer_components/sector/struct.SectorContentsMap.html index 2d0422102d..e91faf683f 100644 --- a/subspace_farmer_components/sector/struct.SectorContentsMap.html +++ b/subspace_farmer_components/sector/struct.SectorContentsMap.html @@ -17,7 +17,7 @@ &self, output: &mut [u8] ) -> Result<(), SectorContentsMapEncodeIntoError>

Encode internal contents into output

-
source

pub fn num_encoded_record_chunks(&self) -> &[SBucket]

Number of encoded chunks in each record

+
source

pub fn num_encoded_record_chunks(&self) -> &[SBucket]

Number of encoded chunks in each record

source

pub fn iter_record_bitfields(&self) -> &[BitArray<[u8; 8192]>]

Iterate over individual record bitfields

source

pub fn iter_record_bitfields_mut( &mut self @@ -25,14 +25,14 @@

source

pub fn s_bucket_sizes(&self) -> Box<[u16; 65536]>

Returns sizes of each s-bucket

source

pub fn iter_record_chunk_to_plot( &self, - piece_offset: PieceOffset -) -> impl Iterator<Item = (SBucket, bool, usize)> + '_

Creates an iterator of (s_bucket, encoded_chunk_used, chunk_location), where s_bucket is + piece_offset: PieceOffset +) -> impl Iterator<Item = (SBucket, bool, usize)> + '_

Creates an iterator of (s_bucket, encoded_chunk_used, chunk_location), where s_bucket is position of the chunk in the erasure coded record, encoded_chunk_used indicates whether it was encoded and chunk_location is the offset of the chunk in the plot (across all s-buckets).

source

pub fn par_iter_record_chunk_to_plot( &self, - piece_offset: PieceOffset + piece_offset: PieceOffset ) -> impl IndexedParallelIterator<Item = Option<(usize, bool)>> + '_

Creates an iterator of Option<(chunk_offset, encoded_chunk_used)>, where each entry corresponds s-bucket/position of the chunk in the erasure coded record, encoded_chunk_used indicates whether it was encoded and chunk_offset is the offset of the chunk in the @@ -41,18 +41,18 @@ all s-buckets and offsets are within corresponding s-buckets rather than the whole plot.

source

pub fn iter_s_bucket_records( &self, - s_bucket: SBucket -) -> Result<impl Iterator<Item = (PieceOffset, bool)> + '_, SectorContentsMapIterationError>

Creates an iterator of (piece_offset, encoded_chunk_used), where piece_offset + s_bucket: SBucket +) -> Result<impl Iterator<Item = (PieceOffset, bool)> + '_, SectorContentsMapIterationError>

Creates an iterator of (piece_offset, encoded_chunk_used), where piece_offset corresponds to the record to which chunk belongs and encoded_chunk_used indicates whether it was encoded.

-

Returns error if s_bucket is outside of [Record::NUM_S_BUCKETS] range.

+

Returns error if s_bucket is outside of Record::NUM_S_BUCKETS range.

source

pub fn iter_s_bucket_encoded_record_chunks_used( &self, - s_bucket: SBucket + s_bucket: SBucket ) -> Result<impl Iterator<Item = bool> + '_, SectorContentsMapIterationError>

Iterate over chunks of s-bucket indicating if encoded chunk is used at corresponding position

Panics
-

Panics if s_bucket is outside of [Record::NUM_S_BUCKETS] range.

+

Panics if s_bucket is outside of Record::NUM_S_BUCKETS range.

Trait Implementations§

source§

impl Clone for SectorContentsMap

source§

fn clone(&self) -> SectorContentsMap

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 SectorContentsMap

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
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 diff --git a/subspace_farmer_components/sector/struct.SectorMetadata.html b/subspace_farmer_components/sector/struct.SectorMetadata.html index 272febd124..e1c0579b01 100644 --- a/subspace_farmer_components/sector/struct.SectorMetadata.html +++ b/subspace_farmer_components/sector/struct.SectorMetadata.html @@ -1,14 +1,14 @@ SectorMetadata in subspace_farmer_components::sector - Rust

Struct subspace_farmer_components::sector::SectorMetadata

source · 
pub struct SectorMetadata {
-    pub sector_index: SectorIndex,
+    pub sector_index: SectorIndex,
     pub pieces_in_sector: u16,
     pub s_bucket_sizes: Box<[u16; 65536]>,
-    pub history_size: HistorySize,
+    pub history_size: HistorySize,
 }
Expand description

Metadata of the plotted sector

-

Fields§

§sector_index: SectorIndex

Sector index

+

Fields§

§sector_index: SectorIndex

Sector index

§pieces_in_sector: u16

Number of pieces stored in this sector

§s_bucket_sizes: Box<[u16; 65536]>

S-bucket sizes in a sector

-
§history_size: HistorySize

Size of the blockchain history at time of sector creation

+
§history_size: HistorySize

Size of the blockchain history at time of sector creation

Implementations§

source§

impl SectorMetadata

source

pub fn s_bucket_offsets(&self) -> Box<[u32; 65536]>

Returns offsets of each s-bucket relatively to the beginning of the sector (in chunks)

Trait Implementations§

source§

impl Clone for SectorMetadata

source§

fn clone(&self) -> SectorMetadata

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 SectorMetadata

source§

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

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

impl Decode for SectorMetadata

source§

fn decode<__CodecInputEdqy: Input>( __codec_input_edqy: &mut __CodecInputEdqy diff --git a/subspace_farmer_components/struct.FarmerProtocolInfo.html b/subspace_farmer_components/struct.FarmerProtocolInfo.html index 845fa34d2e..db58605062 100644 --- a/subspace_farmer_components/struct.FarmerProtocolInfo.html +++ b/subspace_farmer_components/struct.FarmerProtocolInfo.html @@ -1,16 +1,16 @@ FarmerProtocolInfo in subspace_farmer_components - Rust

Struct subspace_farmer_components::FarmerProtocolInfo

source · 
pub struct FarmerProtocolInfo {
-    pub history_size: HistorySize,
+    pub history_size: HistorySize,
     pub max_pieces_in_sector: u16,
-    pub recent_segments: HistorySize,
-    pub recent_history_fraction: (HistorySize, HistorySize),
-    pub min_sector_lifetime: HistorySize,
+    pub recent_segments: HistorySize,
+    pub recent_history_fraction: (HistorySize, HistorySize),
+    pub min_sector_lifetime: HistorySize,
 }
Expand description

Information about the protocol necessary for farmer operation

-

Fields§

§history_size: HistorySize

Size of the blockchain history

+

Fields§

§history_size: HistorySize

Size of the blockchain history

§max_pieces_in_sector: u16

How many pieces one sector is supposed to contain (max)

-
§recent_segments: HistorySize

Number of latest archived segments that are considered “recent history”.

-
§recent_history_fraction: (HistorySize, HistorySize)

Fraction of pieces from the “recent history” (recent_segments) in each sector.

-
§min_sector_lifetime: HistorySize

Minimum lifetime of a plotted sector, measured in archived segment

+
§recent_segments: HistorySize

Number of latest archived segments that are considered “recent history”.

+
§recent_history_fraction: (HistorySize, HistorySize)

Fraction of pieces from the “recent history” (recent_segments) in each sector.

+
§min_sector_lifetime: HistorySize

Minimum lifetime of a plotted sector, measured in archived segment

Trait Implementations§

source§

impl Clone for FarmerProtocolInfo

source§

fn clone(&self) -> FarmerProtocolInfo

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 FarmerProtocolInfo

source§

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

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

impl<'de> Deserialize<'de> for FarmerProtocolInfo

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 Serialize for FarmerProtocolInfo

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 Copy for FarmerProtocolInfo

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where diff --git a/subspace_malicious_operator/malicious_domain_instance_starter/struct.DomainInstanceStarter.html b/subspace_malicious_operator/malicious_domain_instance_starter/struct.DomainInstanceStarter.html index ab67efef5b..572fdeafd2 100644 --- a/subspace_malicious_operator/malicious_domain_instance_starter/struct.DomainInstanceStarter.html +++ b/subspace_malicious_operator/malicious_domain_instance_starter/struct.DomainInstanceStarter.html @@ -3,7 +3,7 @@ pub domain_cli: DomainCli, pub base_path: PathBuf, pub tokio_handle: Handle, - pub consensus_client: Arc<FullClient<RuntimeApi>>, + pub consensus_client: Arc<FullClient<RuntimeApi>>, pub consensus_keystore: KeystorePtr, pub consensus_offchain_tx_pool_factory: OffchainTransactionPoolFactory<Block>, pub block_importing_notification_stream: SubspaceNotificationStream<BlockImportingNotification<Block>>, @@ -14,7 +14,7 @@ pub consensus_network: Arc<CNetwork>, }
Expand description

DomainInstanceStarter used to start a domain instance node based on the given bootstrap result

-

Fields§

§domain_cli: DomainCli§base_path: PathBuf§tokio_handle: Handle§consensus_client: Arc<FullClient<RuntimeApi>>§consensus_keystore: KeystorePtr§consensus_offchain_tx_pool_factory: OffchainTransactionPoolFactory<Block>§block_importing_notification_stream: SubspaceNotificationStream<BlockImportingNotification<Block>>§new_slot_notification_stream: SubspaceNotificationStream<NewSlotNotification>§consensus_sync_service: Arc<SyncingService<Block>>§domain_message_receiver: TracingUnboundedReceiver<ChainTxPoolMsg>§gossip_message_sink: TracingUnboundedSender<Message>§consensus_network: Arc<CNetwork>

Implementations§

source§

impl<CNetwork> DomainInstanceStarter<CNetwork>
where +

Fields§

§domain_cli: DomainCli§base_path: PathBuf§tokio_handle: Handle§consensus_client: Arc<FullClient<RuntimeApi>>§consensus_keystore: KeystorePtr§consensus_offchain_tx_pool_factory: OffchainTransactionPoolFactory<Block>§block_importing_notification_stream: SubspaceNotificationStream<BlockImportingNotification<Block>>§new_slot_notification_stream: SubspaceNotificationStream<NewSlotNotification>§consensus_sync_service: Arc<SyncingService<Block>>§domain_message_receiver: TracingUnboundedReceiver<ChainTxPoolMsg>§gossip_message_sink: TracingUnboundedSender<Message>§consensus_network: Arc<CNetwork>

Implementations§

source§

impl<CNetwork> DomainInstanceStarter<CNetwork>
where CNetwork: NetworkPeers + Send + Sync + 'static,

source

pub async fn start( self, bootstrap_result: BootstrapResult<CBlock> diff --git a/subspace_proof_of_space/chia/struct.ChiaTable.html b/subspace_proof_of_space/chia/struct.ChiaTable.html index 0f69f2c264..84aa52511c 100644 --- a/subspace_proof_of_space/chia/struct.ChiaTable.html +++ b/subspace_proof_of_space/chia/struct.ChiaTable.html @@ -1,11 +1,11 @@ ChiaTable in subspace_proof_of_space::chia - Rust

Struct subspace_proof_of_space::chia::ChiaTable

source · 
pub struct ChiaTable { /* private fields */ }
Expand description

Subspace proof of space table.

Chia implementation.

-

Trait Implementations§

source§

impl Debug for ChiaTable

source§

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

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

impl Table for ChiaTable

source§

const TABLE_TYPE: PosTableType = PosTableType::Chia

Proof of space table type
§

type Generator = ChiaTableGenerator

Instance that can be used to generate tables with better performance
source§

fn generate(seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed. Read more
source§

fn generate_parallel(seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed using parallelism. Read more
source§

fn find_proof(&self, challenge_index: u32) -> Option<PosProof>

Try to find proof at challenge_index if it exists
source§

fn is_proof_valid( - seed: &PosSeed, +

Trait Implementations§

source§

impl Debug for ChiaTable

source§

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

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

impl Table for ChiaTable

source§

const TABLE_TYPE: PosTableType = PosTableType::Chia

Proof of space table type
§

type Generator = ChiaTableGenerator

Instance that can be used to generate tables with better performance
source§

fn generate(seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed. Read more
source§

fn generate_parallel(seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed using parallelism. Read more
source§

fn find_proof(&self, challenge_index: u32) -> Option<PosProof>

Try to find proof at challenge_index if it exists
source§

fn is_proof_valid( + seed: &PosSeed, challenge_index: u32, - proof: &PosProof -) -> bool

Check whether proof created earlier is valid and return quality bytes if yes
source§

fn generator() -> Self::Generator

Returns a stateful table generator with better performance
source§

impl TableGenerator<ChiaTable> for ChiaTableGenerator

source§

fn generate(&mut self, seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed. Read more
source§

fn generate_parallel(&mut self, seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed using parallelism. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + proof: &PosProof +) -> bool

Check whether proof created earlier is valid and return quality bytes if yes
source§

fn generator() -> Self::Generator

Returns a stateful table generator with better performance

source§

impl TableGenerator<ChiaTable> for ChiaTableGenerator

source§

fn generate(&mut self, seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed. Read more
source§

fn generate_parallel(&mut self, seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed using parallelism. 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
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_proof_of_space/chia/struct.ChiaTableGenerator.html b/subspace_proof_of_space/chia/struct.ChiaTableGenerator.html index 078651231b..c543d52e4d 100644 --- a/subspace_proof_of_space/chia/struct.ChiaTableGenerator.html +++ b/subspace_proof_of_space/chia/struct.ChiaTableGenerator.html @@ -1,7 +1,7 @@ ChiaTableGenerator in subspace_proof_of_space::chia - Rust

Struct subspace_proof_of_space::chia::ChiaTableGenerator

source · 
pub struct ChiaTableGenerator { /* private fields */ }
Expand description

Subspace proof of space table generator.

Chia implementation.

-

Trait Implementations§

source§

impl Clone for ChiaTableGenerator

source§

fn clone(&self) -> ChiaTableGenerator

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 ChiaTableGenerator

source§

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

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

impl Default for ChiaTableGenerator

source§

fn default() -> ChiaTableGenerator

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

impl TableGenerator<ChiaTable> for ChiaTableGenerator

source§

fn generate(&mut self, seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed. Read more
source§

fn generate_parallel(&mut self, seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed using parallelism. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where +

Trait Implementations§

source§

impl Clone for ChiaTableGenerator

source§

fn clone(&self) -> ChiaTableGenerator

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 ChiaTableGenerator

source§

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

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

impl Default for ChiaTableGenerator

source§

fn default() -> ChiaTableGenerator

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

impl TableGenerator<ChiaTable> for ChiaTableGenerator

source§

fn generate(&mut self, seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed. Read more
source§

fn generate_parallel(&mut self, seed: &PosSeed) -> ChiaTable

Generate new table with 32 bytes seed using parallelism. 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
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_proof_of_space/shim/struct.ShimTable.html b/subspace_proof_of_space/shim/struct.ShimTable.html index 7e590044c6..96ecb4e757 100644 --- a/subspace_proof_of_space/shim/struct.ShimTable.html +++ b/subspace_proof_of_space/shim/struct.ShimTable.html @@ -1,11 +1,11 @@ ShimTable in subspace_proof_of_space::shim - Rust

Struct subspace_proof_of_space::shim::ShimTable

source · 
pub struct ShimTable { /* private fields */ }
Expand description

Subspace proof of space table.

Shim implementation.

-

Trait Implementations§

source§

impl Debug for ShimTable

source§

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

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

impl Table for ShimTable

source§

const TABLE_TYPE: PosTableType = PosTableType::Shim

Proof of space table type
§

type Generator = ShimTableGenerator

Instance that can be used to generate tables with better performance
source§

fn generate(seed: &PosSeed) -> ShimTable

Generate new table with 32 bytes seed. Read more
source§

fn find_proof(&self, challenge_index: u32) -> Option<PosProof>

Try to find proof at challenge_index if it exists
source§

fn is_proof_valid( - seed: &PosSeed, +

Trait Implementations§

source§

impl Debug for ShimTable

source§

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

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

impl Table for ShimTable

source§

const TABLE_TYPE: PosTableType = PosTableType::Shim

Proof of space table type
§

type Generator = ShimTableGenerator

Instance that can be used to generate tables with better performance
source§

fn generate(seed: &PosSeed) -> ShimTable

Generate new table with 32 bytes seed. Read more
source§

fn find_proof(&self, challenge_index: u32) -> Option<PosProof>

Try to find proof at challenge_index if it exists
source§

fn is_proof_valid( + seed: &PosSeed, challenge_index: u32, - proof: &PosProof -) -> bool

Check whether proof created earlier is valid and return quality bytes if yes
source§

fn generate_parallel(seed: &PosSeed) -> Self

Generate new table with 32 bytes seed using parallelism. Read more
source§

fn generator() -> Self::Generator

Returns a stateful table generator with better performance
source§

impl TableGenerator<ShimTable> for ShimTableGenerator

source§

fn generate(&mut self, seed: &PosSeed) -> ShimTable

Generate new table with 32 bytes seed. Read more
source§

fn generate_parallel(&mut self, seed: &PosSeed) -> T

Generate new table with 32 bytes seed using parallelism. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where + proof: &PosProof +) -> bool

Check whether proof created earlier is valid and return quality bytes if yes
source§

fn generate_parallel(seed: &PosSeed) -> Self

Generate new table with 32 bytes seed using parallelism. Read more
source§

fn generator() -> Self::Generator

Returns a stateful table generator with better performance
source§

impl TableGenerator<ShimTable> for ShimTableGenerator

source§

fn generate(&mut self, seed: &PosSeed) -> ShimTable

Generate new table with 32 bytes seed. Read more
source§

fn generate_parallel(&mut self, seed: &PosSeed) -> T

Generate new table with 32 bytes seed using parallelism. 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
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_proof_of_space/shim/struct.ShimTableGenerator.html b/subspace_proof_of_space/shim/struct.ShimTableGenerator.html index 87225a26f9..1e7f9a1cef 100644 --- a/subspace_proof_of_space/shim/struct.ShimTableGenerator.html +++ b/subspace_proof_of_space/shim/struct.ShimTableGenerator.html @@ -1,7 +1,7 @@ ShimTableGenerator in subspace_proof_of_space::shim - Rust

Struct subspace_proof_of_space::shim::ShimTableGenerator

source · 
pub struct ShimTableGenerator;
Expand description

Subspace proof of space table generator.

Shim implementation.

-

Trait Implementations§

source§

impl Clone for ShimTableGenerator

source§

fn clone(&self) -> ShimTableGenerator

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 ShimTableGenerator

source§

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

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

impl Default for ShimTableGenerator

source§

fn default() -> ShimTableGenerator

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

impl TableGenerator<ShimTable> for ShimTableGenerator

source§

fn generate(&mut self, seed: &PosSeed) -> ShimTable

Generate new table with 32 bytes seed. Read more
source§

fn generate_parallel(&mut self, seed: &PosSeed) -> T

Generate new table with 32 bytes seed using parallelism. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where +

Trait Implementations§

source§

impl Clone for ShimTableGenerator

source§

fn clone(&self) -> ShimTableGenerator

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 ShimTableGenerator

source§

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

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

impl Default for ShimTableGenerator

source§

fn default() -> ShimTableGenerator

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

impl TableGenerator<ShimTable> for ShimTableGenerator

source§

fn generate(&mut self, seed: &PosSeed) -> ShimTable

Generate new table with 32 bytes seed. Read more
source§

fn generate_parallel(&mut self, seed: &PosSeed) -> T

Generate new table with 32 bytes seed using parallelism. 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
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_proof_of_space/trait.Table.html b/subspace_proof_of_space/trait.Table.html index e7f70e58da..972fbc4399 100644 --- a/subspace_proof_of_space/trait.Table.html +++ b/subspace_proof_of_space/trait.Table.html @@ -5,29 +5,29 @@ const TABLE_TYPE: PosTableType; // Required methods - fn generate(seed: &PosSeed) -> Self; - fn find_proof(&self, challenge_index: u32) -> Option<PosProof>; + fn generate(seed: &PosSeed) -> Self; + fn find_proof(&self, challenge_index: u32) -> Option<PosProof>; fn is_proof_valid( - seed: &PosSeed, + seed: &PosSeed, challenge_index: u32, - proof: &PosProof + proof: &PosProof ) -> bool; // Provided methods - fn generate_parallel(seed: &PosSeed) -> Self { ... } + fn generate_parallel(seed: &PosSeed) -> Self { ... } fn generator() -> Self::Generator { ... } }
Expand description

Proof of space kind

Required Associated Types§

source

type Generator: TableGenerator<Self>

Instance that can be used to generate tables with better performance

Required Associated Constants§

source

const TABLE_TYPE: PosTableType

Proof of space table type

-

Required Methods§

source

fn generate(seed: &PosSeed) -> Self

Generate new table with 32 bytes seed.

+

Required Methods§

source

fn generate(seed: &PosSeed) -> Self

Generate new table with 32 bytes seed.

There is also Self::generate_parallel() that can achieve lower latency.

-
source

fn find_proof(&self, challenge_index: u32) -> Option<PosProof>

Try to find proof at challenge_index if it exists

+
source

fn find_proof(&self, challenge_index: u32) -> Option<PosProof>

Try to find proof at challenge_index if it exists

source

fn is_proof_valid( - seed: &PosSeed, + seed: &PosSeed, challenge_index: u32, - proof: &PosProof + proof: &PosProof ) -> bool

Check whether proof created earlier is valid and return quality bytes if yes

-

Provided Methods§

source

fn generate_parallel(seed: &PosSeed) -> Self

Generate new table with 32 bytes seed using parallelism.

+

Provided Methods§

source

fn generate_parallel(seed: &PosSeed) -> Self

Generate new table with 32 bytes seed using parallelism.

This implementation will trade efficiency of CPU and memory usage for lower latency, prefer Self::generate() unless lower latency is critical.

source

fn generator() -> Self::Generator

Returns a stateful table generator with better performance

diff --git a/subspace_proof_of_space/trait.TableGenerator.html b/subspace_proof_of_space/trait.TableGenerator.html index fef08dc7d4..ebbc50e750 100644 --- a/subspace_proof_of_space/trait.TableGenerator.html +++ b/subspace_proof_of_space/trait.TableGenerator.html @@ -1,14 +1,14 @@ TableGenerator in subspace_proof_of_space - Rust

Trait subspace_proof_of_space::TableGenerator

source · 
pub trait TableGenerator<T: Table>: Debug + Default + Clone + Send + Sized + 'static {
     // Required method
-    fn generate(&mut self, seed: &PosSeed) -> T;
+    fn generate(&mut self, seed: &PosSeed) -> T;
 
     // Provided method
-    fn generate_parallel(&mut self, seed: &PosSeed) -> T { ... }
+    fn generate_parallel(&mut self, seed: &PosSeed) -> T { ... }
 }
Expand description

Stateful table generator with better performance

-

Required Methods§

source

fn generate(&mut self, seed: &PosSeed) -> T

Generate new table with 32 bytes seed.

+

Required Methods§

source

fn generate(&mut self, seed: &PosSeed) -> T

Generate new table with 32 bytes seed.

There is also Self::generate_parallel() that can achieve lower latency.

-

Provided Methods§

source

fn generate_parallel(&mut self, seed: &PosSeed) -> T

Generate new table with 32 bytes seed using parallelism.

+

Provided Methods§

source

fn generate_parallel(&mut self, seed: &PosSeed) -> T

Generate new table with 32 bytes seed using parallelism.

This implementation will trade efficiency of CPU and memory usage for lower latency, prefer Self::generate() unless lower latency is critical.

Object Safety§

This trait is not object safe.

Implementors§

\ No newline at end of file diff --git a/subspace_proof_of_time/fn.prove.html b/subspace_proof_of_time/fn.prove.html index f1a3dddc04..e7290822a5 100644 --- a/subspace_proof_of_time/fn.prove.html +++ b/subspace_proof_of_time/fn.prove.html @@ -1,7 +1,7 @@ prove in subspace_proof_of_time - Rust

Function subspace_proof_of_time::prove

source · 
pub fn prove(
-    seed: PotSeed,
+    seed: PotSeed,
     iterations: NonZeroU32
-) -> Result<PotCheckpoints, PotError>
Expand description

Run PoT proving and produce checkpoints.

+) -> Result<PotCheckpoints, PotError>
Expand description

Run PoT proving and produce checkpoints.

Returns error if iterations is not a multiple of checkpoints times two.

\ No newline at end of file diff --git a/subspace_proof_of_time/fn.verify.html b/subspace_proof_of_time/fn.verify.html index 9df846e2b0..f7d3134733 100644 --- a/subspace_proof_of_time/fn.verify.html +++ b/subspace_proof_of_time/fn.verify.html @@ -1,8 +1,8 @@ verify in subspace_proof_of_time - Rust

Function subspace_proof_of_time::verify

source · 
pub fn verify(
-    seed: PotSeed,
+    seed: PotSeed,
     iterations: NonZeroU32,
-    checkpoints: &[PotOutput]
+    checkpoints: &[PotOutput]
 ) -> Result<bool, PotError>
Expand description

Verify checkpoint, number of iterations is set across uniformly distributed checkpoints.

Returns error if iterations is not a multiple of checkpoints times two.

\ No newline at end of file diff --git a/subspace_test_client/chain_spec/type.TestChainSpec.html b/subspace_test_client/chain_spec/type.TestChainSpec.html index 9918acfea7..55ad4f60dc 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 019b8c1435..70a5b097d0 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_verification/enum.Error.html b/subspace_verification/enum.Error.html index 0534899f82..bd8bf2eb31 100644 --- a/subspace_verification/enum.Error.html +++ b/subspace_verification/enum.Error.html @@ -5,13 +5,13 @@ max_pieces_in_sector: u16, }, SectorExpired { - expiration_history_size: HistorySize, - current_history_size: HistorySize, + expiration_history_size: HistorySize, + current_history_size: HistorySize, }, InvalidPiece, OutsideSolutionRange { - half_solution_range: SolutionRange, - solution_distance: SolutionRange, + half_solution_range: SolutionRange, + solution_distance: SolutionRange, }, InvalidProofOfSpace, InvalidAuditChunkOffset, @@ -21,12 +21,12 @@

Variants§

§

InvalidPieceOffset

Fields

§piece_offset: u16

Index of the piece that failed verification

§max_pieces_in_sector: u16

How many pieces one sector is supposed to contain (max)

Invalid piece offset

-
§

SectorExpired

Fields

§expiration_history_size: HistorySize

Expiration history size

-
§current_history_size: HistorySize

Current history size

+
§

SectorExpired

Fields

§expiration_history_size: HistorySize

Expiration history size

+
§current_history_size: HistorySize

Current history size

Sector expired

§

InvalidPiece

Piece verification failed

-
§

OutsideSolutionRange

Fields

§half_solution_range: SolutionRange

Half of solution range

-
§solution_distance: SolutionRange

Solution distance

+
§

OutsideSolutionRange

Fields

§half_solution_range: SolutionRange

Half of solution range

+
§solution_distance: SolutionRange

Solution distance

Solution is outside of challenge range

§

InvalidProofOfSpace

Invalid proof of space

§

InvalidAuditChunkOffset

Invalid audit chunk offset

diff --git a/subspace_verification/fn.calculate_block_weight.html b/subspace_verification/fn.calculate_block_weight.html index e1675d1bcf..8fcad8e5e2 100644 --- a/subspace_verification/fn.calculate_block_weight.html +++ b/subspace_verification/fn.calculate_block_weight.html @@ -1,3 +1,3 @@ calculate_block_weight in subspace_verification - Rust
-

Function subspace_verification::calculate_block_weight

source · 
pub fn calculate_block_weight(solution_range: SolutionRange) -> BlockWeight
Expand description

Calculate weight derived from provided solution range

+

Function subspace_verification::calculate_block_weight

source · 
pub fn calculate_block_weight(solution_range: SolutionRange) -> BlockWeight
Expand description

Calculate weight derived from provided solution range

\ No newline at end of file diff --git a/subspace_verification/fn.check_reward_signature.html b/subspace_verification/fn.check_reward_signature.html index 21e153cefc..d176796ce7 100644 --- a/subspace_verification/fn.check_reward_signature.html +++ b/subspace_verification/fn.check_reward_signature.html @@ -1,8 +1,8 @@ check_reward_signature in subspace_verification - Rust

Function subspace_verification::check_reward_signature

source · 
pub fn check_reward_signature(
     hash: &[u8],
-    signature: &RewardSignature,
-    public_key: &PublicKey,
+    signature: &RewardSignature,
+    public_key: &PublicKey,
     reward_signing_context: &SigningContext
 ) -> Result<(), SignatureError>
Expand description

Check the reward signature validity.

\ No newline at end of file diff --git a/subspace_verification/fn.derive_next_solution_range.html b/subspace_verification/fn.derive_next_solution_range.html index 402fbe1381..42d0342c88 100644 --- a/subspace_verification/fn.derive_next_solution_range.html +++ b/subspace_verification/fn.derive_next_solution_range.html @@ -1,9 +1,9 @@ derive_next_solution_range in subspace_verification - Rust

Function subspace_verification::derive_next_solution_range

source · 
pub fn derive_next_solution_range(
-    start_slot: SlotNumber,
-    current_slot: SlotNumber,
+    start_slot: SlotNumber,
+    current_slot: SlotNumber,
     slot_probability: (u64, u64),
-    current_solution_range: SolutionRange,
-    era_duration: BlockNumber
+    current_solution_range: SolutionRange,
+    era_duration: BlockNumber
 ) -> u64
Expand description

Derives next solution range based on the total era slots and slot probability

\ No newline at end of file diff --git a/subspace_verification/fn.derive_pot_entropy.html b/subspace_verification/fn.derive_pot_entropy.html index dc839e0740..bd203c0ad3 100644 --- a/subspace_verification/fn.derive_pot_entropy.html +++ b/subspace_verification/fn.derive_pot_entropy.html @@ -1,3 +1,3 @@ derive_pot_entropy in subspace_verification - Rust
-

Function subspace_verification::derive_pot_entropy

source · 
pub fn derive_pot_entropy(chunk: Scalar, proof_of_time: PotOutput) -> Blake3Hash
Expand description

Derive proof of time entropy from chunk and proof of time for injection purposes.

+

Function subspace_verification::derive_pot_entropy

source · 
pub fn derive_pot_entropy(chunk: Scalar, proof_of_time: PotOutput) -> Blake3Hash
Expand description

Derive proof of time entropy from chunk and proof of time for injection purposes.

\ No newline at end of file diff --git a/subspace_verification/fn.is_within_solution_range.html b/subspace_verification/fn.is_within_solution_range.html index 6dc780a263..33fecf8e80 100644 --- a/subspace_verification/fn.is_within_solution_range.html +++ b/subspace_verification/fn.is_within_solution_range.html @@ -1,9 +1,9 @@ is_within_solution_range in subspace_verification - Rust

Function subspace_verification::is_within_solution_range

source · 
pub fn is_within_solution_range(
-    global_challenge: &Blake3Hash,
+    global_challenge: &Blake3Hash,
     chunk: &[u8; 32],
-    sector_slot_challenge: &SectorSlotChallenge,
-    solution_range: SolutionRange
-) -> Option<SolutionRange>
Expand description

Returns Some(solution_distance) if solution distance is within the solution range for provided + sector_slot_challenge: &SectorSlotChallenge, + solution_range: SolutionRange +) -> Option<SolutionRange>

Expand description

Returns Some(solution_distance) if solution distance is within the solution range for provided parameters.

\ No newline at end of file diff --git a/subspace_verification/fn.verify_solution.html b/subspace_verification/fn.verify_solution.html index 7e34e62137..387f9cf38a 100644 --- a/subspace_verification/fn.verify_solution.html +++ b/subspace_verification/fn.verify_solution.html @@ -1,11 +1,11 @@ verify_solution in subspace_verification - Rust

Function subspace_verification::verify_solution

source · 
pub fn verify_solution<'a, PosTable, FarmerPublicKey, RewardAddress>(
-    solution: &'a Solution<FarmerPublicKey, RewardAddress>,
-    slot: SlotNumber,
+    solution: &'a Solution<FarmerPublicKey, RewardAddress>,
+    slot: SlotNumber,
     params: &'a VerifySolutionParams,
-    kzg: &'a Kzg
-) -> Result<SolutionRange, Error>
where
+    kzg: &'a Kzg
+) -> Result<SolutionRange, Error>
where
     PosTable: Table,
-    PublicKey: From<&'a FarmerPublicKey>,
Expand description

Verify whether solution is valid, returns solution distance that is <= solution_range/2 on + PublicKey: From<&'a FarmerPublicKey>,

Expand description

Verify whether solution is valid, returns solution distance that is <= solution_range/2 on success.

\ No newline at end of file diff --git a/subspace_verification/struct.PieceCheckParams.html b/subspace_verification/struct.PieceCheckParams.html index 158b635e56..4d42be7e8f 100644 --- a/subspace_verification/struct.PieceCheckParams.html +++ b/subspace_verification/struct.PieceCheckParams.html @@ -1,20 +1,20 @@ PieceCheckParams in subspace_verification - Rust

Struct subspace_verification::PieceCheckParams

source · 
pub struct PieceCheckParams {
     pub max_pieces_in_sector: u16,
-    pub segment_commitment: SegmentCommitment,
-    pub recent_segments: HistorySize,
-    pub recent_history_fraction: (HistorySize, HistorySize),
-    pub min_sector_lifetime: HistorySize,
-    pub current_history_size: HistorySize,
-    pub sector_expiration_check_segment_commitment: Option<SegmentCommitment>,
+    pub segment_commitment: SegmentCommitment,
+    pub recent_segments: HistorySize,
+    pub recent_history_fraction: (HistorySize, HistorySize),
+    pub min_sector_lifetime: HistorySize,
+    pub current_history_size: HistorySize,
+    pub sector_expiration_check_segment_commitment: Option<SegmentCommitment>,
 }
Expand description

Parameters for checking piece validity

Fields§

§max_pieces_in_sector: u16

How many pieces one sector is supposed to contain (max)

-
§segment_commitment: SegmentCommitment

Segment commitment of segment to which piece belongs

-
§recent_segments: HistorySize

Number of latest archived segments that are considered “recent history”

-
§recent_history_fraction: (HistorySize, HistorySize)

Fraction of pieces from the “recent history” (recent_segments) in each sector

-
§min_sector_lifetime: HistorySize

Minimum lifetime of a plotted sector, measured in archived segment

-
§current_history_size: HistorySize

Current size of the history

-
§sector_expiration_check_segment_commitment: Option<SegmentCommitment>

Segment commitment at min_sector_lifetime from sector creation (if exists)

+
§segment_commitment: SegmentCommitment

Segment commitment of segment to which piece belongs

+
§recent_segments: HistorySize

Number of latest archived segments that are considered “recent history”

+
§recent_history_fraction: (HistorySize, HistorySize)

Fraction of pieces from the “recent history” (recent_segments) in each sector

+
§min_sector_lifetime: HistorySize

Minimum lifetime of a plotted sector, measured in archived segment

+
§current_history_size: HistorySize

Current size of the history

+
§sector_expiration_check_segment_commitment: Option<SegmentCommitment>

Segment commitment at min_sector_lifetime from sector creation (if exists)

Trait Implementations§

source§

impl Clone for PieceCheckParams

source§

fn clone(&self) -> PieceCheckParams

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 PieceCheckParams

source§

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

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

impl Decode for PieceCheckParams

source§

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

Attempt to deserialise the value from input.
§

fn decode_into<I>( diff --git a/subspace_verification/struct.VerifySolutionParams.html b/subspace_verification/struct.VerifySolutionParams.html index 1112eaeb20..f11e343b2f 100644 --- a/subspace_verification/struct.VerifySolutionParams.html +++ b/subspace_verification/struct.VerifySolutionParams.html @@ -1,11 +1,11 @@ VerifySolutionParams in subspace_verification - Rust

Struct subspace_verification::VerifySolutionParams

source · 
pub struct VerifySolutionParams {
-    pub proof_of_time: PotOutput,
-    pub solution_range: SolutionRange,
+    pub proof_of_time: PotOutput,
+    pub solution_range: SolutionRange,
     pub piece_check_params: Option<PieceCheckParams>,
 }
Expand description

Parameters for solution verification

-

Fields§

§proof_of_time: PotOutput

Proof of time for which solution is built

-
§solution_range: SolutionRange

Solution range

+

Fields§

§proof_of_time: PotOutput

Proof of time for which solution is built

+
§solution_range: SolutionRange

Solution range

§piece_check_params: Option<PieceCheckParams>

Parameters for checking piece validity.

If None, piece validity check will be skipped.

Trait Implementations§

source§

impl Clone for VerifySolutionParams

source§

fn clone(&self) -> VerifySolutionParams

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 VerifySolutionParams

source§

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

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

impl Decode for VerifySolutionParams

source§

fn decode<__CodecInputEdqy: Input>( diff --git a/trait.impl/clap_builder/derive/trait.Args.js b/trait.impl/clap_builder/derive/trait.Args.js index a614513958..31d426f474 100644 --- a/trait.impl/clap_builder/derive/trait.Args.js +++ b/trait.impl/clap_builder/derive/trait.Args.js @@ -1,4 +1,4 @@ (function() {var implementors = { "domain_eth_service":[["impl Args for EthConfiguration"]], -"subspace_malicious_operator":[["impl Args for DomainCli"],["impl Args for Cli"]] +"subspace_malicious_operator":[["impl Args for Cli"],["impl Args for DomainCli"]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/clap_builder/derive/trait.Parser.js b/trait.impl/clap_builder/derive/trait.Parser.js index 56dd94f994..d3d1c44ed7 100644 --- a/trait.impl/clap_builder/derive/trait.Parser.js +++ b/trait.impl/clap_builder/derive/trait.Parser.js @@ -1,4 +1,4 @@ (function() {var implementors = { "domain_eth_service":[["impl Parser for EthConfiguration"]], -"subspace_malicious_operator":[["impl Parser for DomainCli"],["impl Parser for Cli"]] +"subspace_malicious_operator":[["impl Parser for Cli"],["impl Parser for DomainCli"]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/core/clone/trait.Clone.js b/trait.impl/core/clone/trait.Clone.js index ab0c93f8bb..4aa15f7820 100644 --- a/trait.impl/core/clone/trait.Clone.js +++ b/trait.impl/core/clone/trait.Clone.js @@ -34,7 +34,7 @@ "subspace_archiving":[["impl Clone for ArchiverInstantiationError"],["impl Clone for SegmentItem"],["impl Clone for Archiver"],["impl Clone for NewArchivedSegment"],["impl Clone for ReconstructorInstantiationError"],["impl Clone for ReconstructorError"],["impl Clone for PiecesReconstructor"],["impl Clone for Reconstructor"],["impl Clone for ReconstructorInstantiationError"],["impl Clone for ReconstructorError"],["impl Clone for Segment"],["impl Clone for ReconstructedContents"]], "subspace_core_primitives":[["impl Clone for PieceArray"],["impl Clone for Randomness"],["impl Clone for HistorySize"],["impl Clone for RecordWitness"],["impl Clone for Kzg"],["impl Clone for ArchivedHistorySegment"],["impl Clone for LastArchivedBlock"],["impl Clone for PieceIndex"],["impl Clone for RecordedHistorySegment"],["impl Clone for SectorId"],["impl Clone for SBucket"],["impl Clone for SectorSlotChallenge"],["impl Clone for RawRecord"],["impl Clone for PotOutput"],["impl Clone for PotKey"],["impl Clone for SegmentCommitment"],["impl Clone for PotCheckpoints"],["impl Clone for BlockObject"],["impl<T: Clone> Clone for NonEmptyVec<T>"],["impl Clone for RecordCommitment"],["impl Clone for Scalar"],["impl Clone for Witness"],["impl Clone for Commitment"],["impl Clone for FlatPieces"],["impl Clone for BlockObjectMapping"],["impl Clone for PieceObject"],["impl Clone for PublicKey"],["impl Clone for ArchivedBlockProgress"],["impl Clone for SegmentHeader"],["impl Clone for Polynomial"],["impl Clone for PosSeed"],["impl Clone for U256"],["impl Clone for ChunkWitness"],["impl Clone for Piece"],["impl Clone for RewardSignature"],["impl Clone for PotSeed"],["impl Clone for PieceOffset"],["impl Clone for PieceObjectMapping"],["impl<T: Clone> Clone for Blake3Checksummed<T>"],["impl Clone for PosProof"],["impl<PublicKey: Clone, RewardAddress: Clone> Clone for Solution<PublicKey, RewardAddress>"],["impl Clone for Record"],["impl Clone for GlobalObject"],["impl Clone for SegmentIndex"]], "subspace_erasure_coding":[["impl Clone for ErasureCoding"]], -"subspace_farmer":[["impl Clone for SectorExpirationDetails"],["impl Clone for SingleDiskFarmInfo"],["impl Clone for DiskPieceCache"],["impl Clone for Offset"],["impl Clone for SectorPlottingDetails"],["impl<'a, PosTable> Clone for PlotAuditOptions<'a, PosTable>
where\n PosTable: Table,
"],["impl Clone for FarmingNotification"],["impl Clone for NodeRpcClient"],["impl Clone for SingleDiskFarmId"],["impl Clone for Identity"],["impl Clone for SectorUpdate"],["impl Clone for AuditingDetails"],["impl Clone for ProvingDetails"],["impl Clone for PieceReader"],["impl Clone for PieceCache"],["impl<NC: Clone> Clone for SegmentCommitmentPieceValidator<NC>"],["impl Clone for ProvingResult"],["impl Clone for CpuCoreSet"],["impl Clone for PlottingThreadPoolManager"]], +"subspace_farmer":[["impl Clone for SingleDiskFarmId"],["impl Clone for ProvingDetails"],["impl Clone for PieceCache"],["impl Clone for DiskPieceCache"],["impl Clone for SectorPlottingDetails"],["impl Clone for PlottingThreadPoolManager"],["impl<NC: Clone> Clone for SegmentCommitmentPieceValidator<NC>"],["impl Clone for PieceReader"],["impl Clone for Identity"],["impl Clone for CpuCoreSet"],["impl Clone for FarmingNotification"],["impl Clone for NodeRpcClient"],["impl Clone for SectorExpirationDetails"],["impl Clone for SectorUpdate"],["impl Clone for SingleDiskFarmInfo"],["impl Clone for AuditingDetails"],["impl Clone for ProvingResult"],["impl<'a, PosTable> Clone for PlotAuditOptions<'a, PosTable>
where\n PosTable: Table,
"],["impl Clone for Offset"]], "subspace_farmer_components":[["impl Clone for PlotRecord"],["impl<S, A> Clone for ReadAt<S, A>
where\n S: ReadAtSync + Clone,\n A: ReadAtAsync + Clone,
"],["impl Clone for FarmerProtocolInfo"],["impl Clone for PieceGetterRetryPolicy"],["impl<'a, Sector> Clone for AuditResult<'a, Sector>
where\n Sector: 'a + Clone,
"],["impl Clone for SectorMetadataChecksummed"],["impl Clone for SectorContentsMap"],["impl Clone for SectorContentsMapFromBytesError"],["impl Clone for PlottedSector"],["impl Clone for SectorContentsMapIterationError"],["impl Clone for SectorContentsMapEncodeIntoError"],["impl Clone for SectorMetadata"],["impl<'a, Sector> Clone for SolutionCandidates<'a, Sector>
where\n Sector: Clone + 'a,
"],["impl<'a, T: Clone> Clone for ReadAtOffset<'a, T>"]], "subspace_networking":[["impl Clone for KademliaMode"],["impl Clone for KnownPeersManagerConfig"],["impl Clone for PieceByIndexRequest"],["impl<T: Clone> Clone for KeyWrapper<T>"],["impl Clone for SegmentHeaderRequest"],["impl Clone for MultihashCode"],["impl Clone for PieceByIndexResponse"],["impl Clone for Node"],["impl<K: Clone> Clone for UniqueRecordBinaryHeap<K>"],["impl Clone for RetryPolicy"],["impl Clone for Box<dyn RequestHandler>"],["impl Clone for PeerDiscovered"],["impl Clone for PeerAddressRemovedEvent"],["impl Clone for SegmentHeaderResponse"]], "subspace_proof_of_space":[["impl Clone for PosTableType"],["impl Clone for ChiaTableGenerator"],["impl Clone for ShimTableGenerator"],["impl<const K: u8> Clone for TablesCache<K>"]], diff --git a/trait.impl/core/convert/trait.From.js b/trait.impl/core/convert/trait.From.js index e62a573aec..21566840f2 100644 --- a/trait.impl/core/convert/trait.From.js +++ b/trait.impl/core/convert/trait.From.js @@ -24,7 +24,7 @@ "sp_messenger":[["impl From<DomainId> for ChainId"],["impl From<u32> for ChainId"]], "sp_subspace_mmr":[["impl From<Arc<dyn SubspaceMmrHostFunctions>> for SubspaceMmrExtension"]], "subspace_core_primitives":[["impl From<&Scalar> for [u8; 32]"],["impl From<Scalar> for FsFr"],["impl From<u16> for U256"],["impl From<&[u8; 31]> for Scalar"],["impl From<SegmentCommitment> for [u8; 48]"],["impl From<[u8; 160]> for PosProof"],["impl From<Commitment> for RecordCommitment"],["impl From<Witness> for [u8; 48]"],["impl From<[u8; 48]> for RecordWitness"],["impl From<u16> for PieceOffset"],["impl From<RecordCommitment> for [u8; 48]"],["impl From<PublicKey> for [u8; 32]"],["impl From<PieceOffset> for u32"],["impl From<Scalar> for [u8; 32]"],["impl From<[u8; 48]> for ChunkWitness"],["impl From<HistorySize> for NonZeroU64"],["impl From<Commitment> for FsG1"],["impl From<RewardSignature> for [u8; 64]"],["impl From<PieceIndex> for u64"],["impl From<[u8; 16]> for PotOutput"],["impl From<u8> for U256"],["impl From<NonZeroU64> for HistorySize"],["impl From<Commitment> for SegmentCommitment"],["impl From<PosSeed> for [u8; 32]"],["impl From<[u8; 48]> for SegmentCommitment"],["impl From<[u8; 48]> for RecordCommitment"],["impl From<PieceArray> for FlatPieces"],["impl From<SBucket> for u32"],["impl From<[u8; 32]> for PublicKey"],["impl From<PosProof> for [u8; 160]"],["impl From<ChunkWitness> for [u8; 48]"],["impl From<u128> for U256"],["impl From<SBucket> for u16"],["impl From<SBucket> for usize"],["impl From<SegmentIndex> for u64"],["impl From<RecordWitness> for [u8; 48]"],["impl From<PieceOffset> for usize"],["impl From<FsG1> for Commitment"],["impl From<Witness> for ChunkWitness"],["impl From<[u8; 16]> for PotKey"],["impl From<&PieceArray> for Piece"],["impl From<&Witness> for [u8; 48]"],["impl From<Piece> for Vec<u8>"],["impl From<PieceOffset> for u16"],["impl From<u16> for SBucket"],["impl From<PieceOffset> for u64"],["impl From<[u8; 64]> for RewardSignature"],["impl From<u32> for U256"],["impl From<FsFr> for Scalar"],["impl From<&Commitment> for [u8; 48]"],["impl From<[u8; 16]> for PotSeed"],["impl From<u64> for SegmentIndex"],["impl From<[u8; 31]> for Scalar"],["impl From<Witness> for RecordWitness"],["impl From<[u8; 32]> for Randomness"],["impl From<Witness> for FsG1"],["impl From<FsG1> for Witness"],["impl From<SegmentIndex> for HistorySize"],["impl From<[u8; 32]> for PosSeed"],["impl From<Commitment> for [u8; 48]"],["impl From<u64> for PieceIndex"],["impl From<Randomness> for [u8; 32]"],["impl From<FsPoly> for Polynomial"],["impl From<u64> for U256"]], -"subspace_farmer":[["impl From<DiskPieceCacheError> for SingleDiskFarmError"],["impl From<Ulid> for SingleDiskFarmId"],["impl From<AuditingError> for FarmingError"],["impl From<FarmingError> for BackgroundTaskError"],["impl From<Error> for SingleDiskFarmError"],["impl From<Error> for FarmingError"],["impl From<PlottingError> for BackgroundTaskError"],["impl From<Error> for PlottingError"],["impl From<Box<dyn Error + Sync + Send>> for BackgroundTaskError"],["impl From<ThreadPoolBuildError> for FarmingError"],["impl From<PlottingError> for PlottingError"],["impl From<ProvingError> for FarmingError"],["impl From<Error> for DiskPieceCacheError"]], +"subspace_farmer":[["impl From<Error> for FarmingError"],["impl From<PlottingError> for PlottingError"],["impl From<AuditingError> for FarmingError"],["impl From<FarmingError> for BackgroundTaskError"],["impl From<ProvingError> for FarmingError"],["impl From<Error> for SingleDiskFarmError"],["impl From<Error> for PlottingError"],["impl From<Error> for DiskPieceCacheError"],["impl From<PlottingError> for BackgroundTaskError"],["impl From<Ulid> for SingleDiskFarmId"],["impl From<ThreadPoolBuildError> for FarmingError"],["impl From<DiskPieceCacheError> for SingleDiskFarmError"],["impl From<Box<dyn Error + Sync + Send>> for BackgroundTaskError"]], "subspace_farmer_components":[["impl From<SectorContentsMapFromBytesError> for ProvingError"],["impl From<SectorContentsMapFromBytesError> for ReadingError"],["impl From<SectorMetadata> for SectorMetadataChecksummed"],["impl From<Vec<u8>> for AsyncReadBytes<Vec<u8>>"],["impl From<Box<[u8]>> for AsyncReadBytes<Box<[u8]>>"],["impl From<Error> for ProvingError"],["impl From<AcquireError> for PlottingError"],["impl From<Error> for ReadingError"],["impl From<ReadingError> for ProvingError"]], "subspace_networking":[["impl From<Canceled> for GetClosestPeersError"],["impl From<SendError> for SubscribeError"],["impl From<MultihashCode> for u64"],["impl From<Error> for KnownPeersManagerPersistenceError"],["impl From<SendError> for SendRequestError"],["impl From<KeyWrapper<PieceIndex>> for RecordKey"],["impl From<Canceled> for SubscribeError"],["impl From<Error> for CreationError"],["impl From<TransportError<Error>> for CreationError"],["impl From<Error> for SendRequestError"],["impl From<SubscriptionError> for SubscribeError"],["impl From<SendError> for GetClosestPeersError"],["impl From<Canceled> for SendRequestError"]], "subspace_runtime":[["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<Event<Runtime>> for RuntimeEvent"],["impl From<Event<Runtime>> for RuntimeEvent"],["impl From<Event> for RuntimeEvent"],["impl From<Error<Runtime>> for RuntimeError"],["impl From<Event<Runtime>> for RuntimeEvent"],["impl From<Event<Runtime>> for RuntimeEvent"],["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<Event<Runtime>> for RuntimeEvent"],["impl From<RawOrigin<<Runtime as Config>::AccountId>> for OriginCaller"],["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<Event<Runtime>> for RuntimeEvent"],["impl From<Error<Runtime>> for RuntimeError"],["impl From<Error<Runtime>> for RuntimeError"],["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<Error<Runtime>> for RuntimeError"],["impl From<Event> for RuntimeEvent"],["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<Error<Runtime>> for RuntimeError"],["impl From<Event<Runtime>> for RuntimeEvent"],["impl From<RawOrigin<<Runtime as Config>::AccountId>> for RuntimeOrigin"],["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<Error<Runtime>> for RuntimeError"],["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<RuntimeOrigin> for Result<Origin<Runtime>, RuntimeOrigin>"],["impl From<Event<Runtime>> for RuntimeEvent"],["impl From<Event<Runtime>> for RuntimeEvent"],["impl From<Event<Runtime>> for RuntimeEvent"],["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<Option<<Runtime as Config>::AccountId>> for RuntimeOrigin"],["impl From<OriginCaller> for RuntimeOrigin"],["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<Error<Runtime>> for RuntimeError"],["impl From<Error<Runtime>> for RuntimeError"],["impl From<Error<Runtime>> for RuntimeError"],["impl From<<Pallet<Runtime> as Callable<Runtime>>::RuntimeCall> for RuntimeCall"],["impl From<Event<Runtime>> for RuntimeEvent"]], diff --git a/trait.impl/core/error/trait.Error.js b/trait.impl/core/error/trait.Error.js index 4802ab8ad3..d131eaaa21 100644 --- a/trait.impl/core/error/trait.Error.js +++ b/trait.impl/core/error/trait.Error.js @@ -4,7 +4,7 @@ "sp_consensus_subspace":[["impl Error for Error"]], "sp_domains_fraud_proof":[["impl Error for InvalidBundleEquivocationError"],["impl<DomainHash> Error for VerificationError<DomainHash>
where\n Self: Debug + Display,
"]], "subspace_archiving":[["impl Error for ArchiverInstantiationError"],["impl Error for ReconstructorInstantiationError"],["impl Error for ReconstructorInstantiationError"],["impl Error for ReconstructorError"],["impl Error for ReconstructorError"]], -"subspace_farmer":[["impl Error for Ss58ParsingError"],["impl Error for FarmingError"],["impl Error for BackgroundTaskError"],["impl Error for PlottingError"],["impl Error for DiskPieceCacheError"],["impl Error for SingleDiskFarmError"],["impl Error for SingleDiskFarmScrubError"]], +"subspace_farmer":[["impl Error for FarmingError"],["impl Error for PlottingError"],["impl Error for SingleDiskFarmScrubError"],["impl Error for Ss58ParsingError"],["impl Error for SingleDiskFarmError"],["impl Error for DiskPieceCacheError"],["impl Error for BackgroundTaskError"]], "subspace_farmer_components":[["impl Error for ReadingError"],["impl Error for SectorContentsMapIterationError"],["impl Error for AuditingError"],["impl Error for SectorContentsMapFromBytesError"],["impl Error for ProvingError"],["impl Error for PlottingError"],["impl Error for SectorContentsMapEncodeIntoError"]], "subspace_networking":[["impl Error for SubscribeError"],["impl Error for CreationError"],["impl Error for GetClosestPeersError"],["impl Error for SendRequestError"],["impl Error for KnownPeersManagerPersistenceError"]], "subspace_proof_of_time":[["impl Error for PotError"]], diff --git a/trait.impl/core/fmt/trait.Debug.js b/trait.impl/core/fmt/trait.Debug.js index bd12d9bd5d..dd46490ca2 100644 --- a/trait.impl/core/fmt/trait.Debug.js +++ b/trait.impl/core/fmt/trait.Debug.js @@ -38,7 +38,7 @@ "subspace_archiving":[["impl Debug for ReconstructedContents"],["impl Debug for ArchiverInstantiationError"],["impl Debug for NewArchivedSegment"],["impl Debug for PiecesReconstructor"],["impl Debug for ReconstructorInstantiationError"],["impl Debug for ReconstructorInstantiationError"],["impl Debug for SegmentItem"],["impl Debug for ReconstructorError"],["impl Debug for Reconstructor"],["impl Debug for Archiver"],["impl Debug for Segment"],["impl Debug for ReconstructorError"]], "subspace_core_primitives":[["impl Debug for RecordedHistorySegment"],["impl Debug for PieceIndex"],["impl Debug for PieceObject"],["impl Debug for PotCheckpoints"],["impl Debug for SectorId"],["impl Debug for U256"],["impl Debug for Record"],["impl Debug for SegmentCommitment"],["impl Debug for PieceOffset"],["impl Debug for BlockObject"],["impl Debug for LastArchivedBlock"],["impl Debug for PosSeed"],["impl Debug for PieceObjectMapping"],["impl Debug for PosProof"],["impl Debug for RecordCommitment"],["impl Debug for Polynomial"],["impl Debug for Randomness"],["impl Debug for SegmentIndex"],["impl Debug for BlockObjectMapping"],["impl Debug for ArchivedHistorySegment"],["impl Debug for RecordWitness"],["impl Debug for PublicKey"],["impl Debug for Witness"],["impl Debug for RawRecord"],["impl Debug for PotKey"],["impl Debug for HistorySize"],["impl Debug for FlatPieces"],["impl Debug for Scalar"],["impl Debug for RewardSignature"],["impl<T: Debug> Debug for Blake3Checksummed<T>"],["impl Debug for Kzg"],["impl Debug for ArchivedBlockProgress"],["impl Debug for ChunkWitness"],["impl Debug for SectorSlotChallenge"],["impl Debug for GlobalObject"],["impl Debug for PieceArray"],["impl Debug for Piece"],["impl Debug for PotSeed"],["impl Debug for SegmentHeader"],["impl Debug for Commitment"],["impl<T: Debug> Debug for NonEmptyVec<T>"],["impl Debug for SBucket"],["impl Debug for NonEmptyVecErr"],["impl<PublicKey: Debug, RewardAddress: Debug> Debug for Solution<PublicKey, RewardAddress>"],["impl Debug for PotOutput"]], "subspace_erasure_coding":[["impl Debug for ErasureCoding"]], -"subspace_farmer":[["impl Debug for ProvingDetails"],["impl Debug for Ss58ParsingError"],["impl Debug for SingleDiskFarmError"],["impl<NC> Debug for CacheWorker<NC>
where\n NC: Debug + Debug,
"],["impl Debug for CpuCoreSet"],["impl Debug for PieceCache"],["impl Debug for BackgroundTaskError"],["impl Debug for SectorPlottingDetails"],["impl Debug for PlottingThreadPoolPair"],["impl Debug for Offset"],["impl Debug for SectorUpdate"],["impl Debug for SingleDiskFarmInfo"],["impl Debug for DiskPieceCache"],["impl Debug for AuditingDetails"],["impl Debug for NodeRpcClient"],["impl Debug for ReadersAndPieces"],["impl Debug for PlottingError"],["impl Debug for SingleDiskFarmId"],["impl Debug for DiskPieceCacheError"],["impl Debug for SectorExpirationDetails"],["impl Debug for FarmingNotification"],["impl Debug for PlottingThreadPoolManager"],["impl Debug for PieceReader"],["impl Debug for FarmingError"],["impl Debug for ProvingResult"],["impl Debug for SingleDiskFarmScrubError"],["impl Debug for PlottingThreadPoolsGuard"],["impl Debug for SingleDiskFarmSummary"],["impl<'a, PosTable> Debug for PlotAuditOptions<'a, PosTable>
where\n PosTable: Table + Debug,\n PosTable::Generator: Debug,
"],["impl Debug for DecodedFarmingError"]], +"subspace_farmer":[["impl Debug for ReadersAndPieces"],["impl Debug for DecodedFarmingError"],["impl Debug for FarmingNotification"],["impl Debug for SectorExpirationDetails"],["impl Debug for PlottingError"],["impl Debug for SectorPlottingDetails"],["impl Debug for SingleDiskFarmScrubError"],["impl Debug for PlottingThreadPoolsGuard"],["impl Debug for AuditingDetails"],["impl<NC> Debug for CacheWorker<NC>
where\n NC: Debug + Debug,
"],["impl Debug for SingleDiskFarmError"],["impl Debug for PlottingThreadPoolPair"],["impl Debug for SingleDiskFarmSummary"],["impl Debug for SingleDiskFarmId"],["impl Debug for ProvingResult"],["impl Debug for NodeRpcClient"],["impl Debug for SectorUpdate"],["impl Debug for DiskPieceCache"],["impl Debug for SingleDiskFarmInfo"],["impl Debug for FarmingError"],["impl Debug for Offset"],["impl Debug for Ss58ParsingError"],["impl Debug for PlottingThreadPoolManager"],["impl Debug for PieceReader"],["impl Debug for CpuCoreSet"],["impl Debug for BackgroundTaskError"],["impl Debug for ProvingDetails"],["impl Debug for PieceCache"],["impl Debug for DiskPieceCacheError"],["impl<'a, PosTable> Debug for PlotAuditOptions<'a, PosTable>
where\n PosTable: Table + Debug,\n PosTable::Generator: Debug,
"]], "subspace_farmer_components":[["impl Debug for SectorContentsMap"],["impl Debug for ReadingError"],["impl Debug for PlottingError"],["impl Debug for PlottedSector"],["impl Debug for FarmerProtocolInfo"],["impl Debug for SectorContentsMapIterationError"],["impl Debug for PieceGetterRetryPolicy"],["impl<'a, Sector> Debug for SolutionCandidates<'a, Sector>
where\n Sector: 'a + Debug,
"],["impl Debug for ProvingError"],["impl Debug for PlotRecord"],["impl<'a, Sector> Debug for AuditResult<'a, Sector>
where\n Sector: 'a + Debug,
"],["impl Debug for SectorMetadata"],["impl Debug for SectorContentsMapEncodeIntoError"],["impl Debug for SectorContentsMapFromBytesError"],["impl Debug for SectorMetadataChecksummed"],["impl<'a, T: Debug> Debug for ReadAtOffset<'a, T>"],["impl Debug for AuditingError"]], "subspace_malicious_operator":[["impl Debug for Cli"],["impl Debug for DomainCli"]], "subspace_networking":[["impl Debug for SendRequestError"],["impl<T: Debug> Debug for KeyWrapper<T>"],["impl Debug for MultihashCode"],["impl<LocalRecordProvider> Debug for NodeRunner<LocalRecordProvider>
where\n LocalRecordProvider: LocalRecordProvider + Send + Sync + 'static,
"],["impl Debug for Node"],["impl Debug for PeerAddressRemovedEvent"],["impl Debug for KnownPeersManagerPersistenceError"],["impl Debug for RetryPolicy"],["impl Debug for SubscribeError"],["impl Debug for PieceByIndexRequest"],["impl Debug for SegmentHeaderResponse"],["impl Debug for CreationError"],["impl<K: Debug> Debug for UniqueRecordBinaryHeap<K>"],["impl Debug for PeerDiscovered"],["impl<LocalRecordProvider> Debug for Config<LocalRecordProvider>"],["impl Debug for SegmentHeaderRequest"],["impl Debug for GetClosestPeersError"],["impl Debug for TopicSubscription"],["impl Debug for KnownPeersManagerConfig"],["impl Debug for PieceByIndexResponse"],["impl Debug for KademliaMode"]], diff --git a/trait.impl/core/fmt/trait.Display.js b/trait.impl/core/fmt/trait.Display.js index 291a330365..be8fa87eb6 100644 --- a/trait.impl/core/fmt/trait.Display.js +++ b/trait.impl/core/fmt/trait.Display.js @@ -6,7 +6,7 @@ "sp_domains_fraud_proof":[["impl<DomainHash> Display for VerificationError<DomainHash>
where\n BundleValidity<DomainHash>: Debug,
"],["impl Display for InvalidBundleEquivocationError"]], "subspace_archiving":[["impl Display for ArchiverInstantiationError"],["impl Display for ReconstructorError"],["impl Display for ReconstructorInstantiationError"],["impl Display for ReconstructorError"],["impl Display for ReconstructorInstantiationError"]], "subspace_core_primitives":[["impl Display for PieceOffset"],["impl Display for PieceIndex"],["impl Display for SBucket"],["impl Display for PotOutput"],["impl Display for U256"],["impl Display for SegmentIndex"],["impl Display for PotSeed"],["impl Display for PotKey"],["impl Display for HistorySize"],["impl Display for PublicKey"]], -"subspace_farmer":[["impl Display for Offset"],["impl Display for Ss58ParsingError"],["impl Display for PlottingError"],["impl Display for ProvingResult"],["impl Display for FarmingError"],["impl Display for SingleDiskFarmError"],["impl Display for DecodedFarmingError"],["impl Display for BackgroundTaskError"],["impl Display for SingleDiskFarmId"],["impl Display for SingleDiskFarmScrubError"],["impl Display for DiskPieceCacheError"]], +"subspace_farmer":[["impl Display for SingleDiskFarmScrubError"],["impl Display for SingleDiskFarmId"],["impl Display for BackgroundTaskError"],["impl Display for DecodedFarmingError"],["impl Display for PlottingError"],["impl Display for DiskPieceCacheError"],["impl Display for FarmingError"],["impl Display for SingleDiskFarmError"],["impl Display for Offset"],["impl Display for Ss58ParsingError"],["impl Display for ProvingResult"]], "subspace_farmer_components":[["impl Display for SectorContentsMapEncodeIntoError"],["impl Display for SectorContentsMapFromBytesError"],["impl Display for ProvingError"],["impl Display for ReadingError"],["impl Display for AuditingError"],["impl Display for SectorContentsMapIterationError"],["impl Display for PlottingError"]], "subspace_networking":[["impl Display for GetClosestPeersError"],["impl Display for SendRequestError"],["impl Display for SubscribeError"],["impl Display for CreationError"],["impl Display for KnownPeersManagerPersistenceError"]], "subspace_proof_of_time":[["impl Display for PotError"]], diff --git a/trait.impl/core/marker/trait.Copy.js b/trait.impl/core/marker/trait.Copy.js index ac58360f40..98493a16a5 100644 --- a/trait.impl/core/marker/trait.Copy.js +++ b/trait.impl/core/marker/trait.Copy.js @@ -11,7 +11,7 @@ "sp_domains":[["impl Copy for DomainId"],["impl Copy for DomainsHoldIdentifier"],["impl Copy for StakingHoldIdentifier"]], "sp_messenger":[["impl<Balance: Copy> Copy for InitiateChannelParams<Balance>"],["impl<Balance: Copy> Copy for FeeModel<Balance>"],["impl Copy for ChainId"]], "subspace_core_primitives":[["impl Copy for PosProof"],["impl Copy for SegmentIndex"],["impl Copy for SegmentCommitment"],["impl Copy for SectorId"],["impl Copy for PieceOffset"],["impl Copy for PotCheckpoints"],["impl Copy for RawRecord"],["impl Copy for Randomness"],["impl Copy for U256"],["impl Copy for PotOutput"],["impl Copy for ArchivedBlockProgress"],["impl Copy for Commitment"],["impl Copy for HistorySize"],["impl Copy for RecordedHistorySegment"],["impl Copy for GlobalObject"],["impl Copy for ChunkWitness"],["impl Copy for PieceArray"],["impl Copy for PotSeed"],["impl Copy for Witness"],["impl Copy for PosSeed"],["impl Copy for PotKey"],["impl Copy for PieceObject"],["impl Copy for BlockObject"],["impl Copy for Scalar"],["impl Copy for Record"],["impl Copy for LastArchivedBlock"],["impl Copy for SegmentHeader"],["impl Copy for SBucket"],["impl Copy for PublicKey"],["impl Copy for RecordWitness"],["impl Copy for PieceIndex"],["impl Copy for RecordCommitment"],["impl Copy for RewardSignature"],["impl Copy for SectorSlotChallenge"]], -"subspace_farmer":[["impl<'a, PosTable> Copy for PlotAuditOptions<'a, PosTable>
where\n PosTable: Table,
"],["impl Copy for AuditingDetails"],["impl Copy for ProvingDetails"],["impl Copy for Offset"],["impl Copy for ProvingResult"],["impl Copy for SingleDiskFarmId"]], +"subspace_farmer":[["impl Copy for ProvingResult"],["impl Copy for Offset"],["impl Copy for SingleDiskFarmId"],["impl<'a, PosTable> Copy for PlotAuditOptions<'a, PosTable>
where\n PosTable: Table,
"],["impl Copy for ProvingDetails"],["impl Copy for AuditingDetails"]], "subspace_farmer_components":[["impl<'a, T: Copy> Copy for ReadAtOffset<'a, T>"],["impl Copy for PieceGetterRetryPolicy"],["impl Copy for SectorContentsMapIterationError"],["impl<S, A> Copy for ReadAt<S, A>
where\n S: ReadAtSync + Copy,\n A: ReadAtAsync + Copy,
"],["impl Copy for SectorContentsMapFromBytesError"],["impl Copy for FarmerProtocolInfo"],["impl Copy for SectorContentsMapEncodeIntoError"]], "subspace_networking":[["impl Copy for RetryPolicy"],["impl Copy for PieceByIndexRequest"],["impl<T: Copy> Copy for KeyWrapper<T>"]], "subspace_proof_of_space":[["impl Copy for PosTableType"]], diff --git a/trait.impl/core/marker/trait.Sync.js b/trait.impl/core/marker/trait.Sync.js index a56031372f..8b8f5a2b34 100644 --- a/trait.impl/core/marker/trait.Sync.js +++ b/trait.impl/core/marker/trait.Sync.js @@ -42,7 +42,7 @@ "subspace_core_primitives":[["impl<T> Sync for Blake3Checksummed<T>
where\n T: Sync,
",1,["subspace_core_primitives::checksum::Blake3Checksummed"]],["impl Sync for Polynomial",1,["subspace_core_primitives::crypto::kzg::Polynomial"]],["impl Sync for Commitment",1,["subspace_core_primitives::crypto::kzg::Commitment"]],["impl Sync for Witness",1,["subspace_core_primitives::crypto::kzg::Witness"]],["impl Sync for Kzg",1,["subspace_core_primitives::crypto::kzg::Kzg"]],["impl Sync for Scalar",1,["subspace_core_primitives::crypto::Scalar"]],["impl Sync for BlockObject",1,["subspace_core_primitives::objects::BlockObject"]],["impl Sync for BlockObjectMapping",1,["subspace_core_primitives::objects::BlockObjectMapping"]],["impl Sync for PieceObject",1,["subspace_core_primitives::objects::PieceObject"]],["impl Sync for PieceObjectMapping",1,["subspace_core_primitives::objects::PieceObjectMapping"]],["impl Sync for GlobalObject",1,["subspace_core_primitives::objects::GlobalObject"]],["impl Sync for SBucket",1,["subspace_core_primitives::pieces::SBucket"]],["impl Sync for PieceIndex",1,["subspace_core_primitives::pieces::PieceIndex"]],["impl Sync for PieceOffset",1,["subspace_core_primitives::pieces::PieceOffset"]],["impl Sync for RawRecord",1,["subspace_core_primitives::pieces::RawRecord"]],["impl Sync for Record",1,["subspace_core_primitives::pieces::Record"]],["impl Sync for RecordCommitment",1,["subspace_core_primitives::pieces::RecordCommitment"]],["impl Sync for RecordWitness",1,["subspace_core_primitives::pieces::RecordWitness"]],["impl Sync for ChunkWitness",1,["subspace_core_primitives::pieces::ChunkWitness"]],["impl Sync for Piece",1,["subspace_core_primitives::pieces::Piece"]],["impl Sync for PieceArray",1,["subspace_core_primitives::pieces::PieceArray"]],["impl Sync for FlatPieces",1,["subspace_core_primitives::pieces::FlatPieces"]],["impl Sync for SegmentIndex",1,["subspace_core_primitives::segments::SegmentIndex"]],["impl Sync for SegmentCommitment",1,["subspace_core_primitives::segments::SegmentCommitment"]],["impl Sync for HistorySize",1,["subspace_core_primitives::segments::HistorySize"]],["impl Sync for RecordedHistorySegment",1,["subspace_core_primitives::segments::RecordedHistorySegment"]],["impl Sync for ArchivedHistorySegment",1,["subspace_core_primitives::segments::ArchivedHistorySegment"]],["impl Sync for Randomness",1,["subspace_core_primitives::Randomness"]],["impl Sync for PosSeed",1,["subspace_core_primitives::PosSeed"]],["impl Sync for PosProof",1,["subspace_core_primitives::PosProof"]],["impl Sync for PotKey",1,["subspace_core_primitives::PotKey"]],["impl Sync for PotSeed",1,["subspace_core_primitives::PotSeed"]],["impl Sync for PotOutput",1,["subspace_core_primitives::PotOutput"]],["impl Sync for PotCheckpoints",1,["subspace_core_primitives::PotCheckpoints"]],["impl Sync for PublicKey",1,["subspace_core_primitives::PublicKey"]],["impl Sync for RewardSignature",1,["subspace_core_primitives::RewardSignature"]],["impl Sync for ArchivedBlockProgress",1,["subspace_core_primitives::ArchivedBlockProgress"]],["impl Sync for LastArchivedBlock",1,["subspace_core_primitives::LastArchivedBlock"]],["impl Sync for SegmentHeader",1,["subspace_core_primitives::SegmentHeader"]],["impl<PublicKey, RewardAddress> Sync for Solution<PublicKey, RewardAddress>
where\n PublicKey: Sync,\n RewardAddress: Sync,
",1,["subspace_core_primitives::Solution"]],["impl Sync for U256",1,["subspace_core_primitives::U256"]],["impl Sync for SectorSlotChallenge",1,["subspace_core_primitives::SectorSlotChallenge"]],["impl Sync for SectorId",1,["subspace_core_primitives::SectorId"]],["impl<T> Sync for NonEmptyVec<T>
where\n T: Sync,
",1,["subspace_core_primitives::NonEmptyVec"]],["impl Sync for NonEmptyVecErr",1,["subspace_core_primitives::NonEmptyVecErr"]]], "subspace_erasure_coding":[["impl Sync for ErasureCoding",1,["subspace_erasure_coding::ErasureCoding"]]], "subspace_farmer":[["impl Sync for Identity",1,["subspace_farmer::identity::Identity"]],["impl Sync for NodeRpcClient",1,["subspace_farmer::node_client::node_rpc_client::NodeRpcClient"]],["impl<NC> Sync for CacheWorker<NC>
where\n NC: Sync,
",1,["subspace_farmer::piece_cache::CacheWorker"]],["impl Sync for PieceCache",1,["subspace_farmer::piece_cache::PieceCache"]],["impl Sync for RayonFiles",1,["subspace_farmer::single_disk_farm::farming::rayon_files::RayonFiles"]],["impl Sync for AuditingDetails",1,["subspace_farmer::single_disk_farm::farming::AuditingDetails"]],["impl Sync for ProvingResult",1,["subspace_farmer::single_disk_farm::farming::ProvingResult"]],["impl Sync for ProvingDetails",1,["subspace_farmer::single_disk_farm::farming::ProvingDetails"]],["impl Sync for FarmingNotification",1,["subspace_farmer::single_disk_farm::farming::FarmingNotification"]],["impl Sync for DecodedFarmingError",1,["subspace_farmer::single_disk_farm::farming::DecodedFarmingError"]],["impl Sync for FarmingError",1,["subspace_farmer::single_disk_farm::farming::FarmingError"]],["impl<'a, PosTable> Sync for PlotAuditOptions<'a, PosTable>",1,["subspace_farmer::single_disk_farm::farming::PlotAuditOptions"]],["impl<Plot> Sync for PlotAudit<Plot>",1,["subspace_farmer::single_disk_farm::farming::PlotAudit"]],["impl Sync for DiskPieceCacheError",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"]],["impl Sync for Offset",1,["subspace_farmer::single_disk_farm::piece_cache::Offset"]],["impl Sync for DiskPieceCache",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCache"]],["impl Sync for PieceReader",1,["subspace_farmer::single_disk_farm::piece_reader::PieceReader"]],["impl Sync for SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorPlottingDetails"]],["impl Sync for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorExpirationDetails"]],["impl Sync for PlottingError",1,["subspace_farmer::single_disk_farm::plotting::PlottingError"]],["impl Sync for SingleDiskFarmId",1,["subspace_farmer::single_disk_farm::SingleDiskFarmId"]],["impl Sync for SingleDiskFarmInfoLock",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock"]],["impl Sync for SingleDiskFarmInfo",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfo"]],["impl Sync for SingleDiskFarmSummary",1,["subspace_farmer::single_disk_farm::SingleDiskFarmSummary"]],["impl<NC, PG> Sync for SingleDiskFarmOptions<NC, PG>
where\n NC: Sync,\n PG: Sync,
",1,["subspace_farmer::single_disk_farm::SingleDiskFarmOptions"]],["impl Sync for SingleDiskFarmError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmError"]],["impl Sync for SingleDiskFarmScrubError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"]],["impl Sync for BackgroundTaskError",1,["subspace_farmer::single_disk_farm::BackgroundTaskError"]],["impl Sync for SectorUpdate",1,["subspace_farmer::single_disk_farm::SectorUpdate"]],["impl !Sync for SingleDiskFarm",1,["subspace_farmer::single_disk_farm::SingleDiskFarm"]],["impl Sync for PlottingThreadPoolPair",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolPair"]],["impl Sync for PlottingThreadPoolsGuard",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolsGuard"]],["impl Sync for PlottingThreadPoolManager",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolManager"]],["impl<PV, NC> Sync for FarmerPieceGetter<PV, NC>
where\n NC: Sync,\n PV: Sync,
",1,["subspace_farmer::utils::farmer_piece_getter::FarmerPieceGetter"]],["impl<NC> Sync for SegmentCommitmentPieceValidator<NC>
where\n NC: Sync,
",1,["subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator"]],["impl Sync for ReadersAndPieces",1,["subspace_farmer::utils::readers_and_pieces::ReadersAndPieces"]],["impl Sync for Ss58ParsingError",1,["subspace_farmer::utils::ss58::Ss58ParsingError"]],["impl<T> Sync for AsyncJoinOnDrop<T>
where\n T: Send,
",1,["subspace_farmer::utils::AsyncJoinOnDrop"]],["impl Sync for CpuCoreSet",1,["subspace_farmer::utils::CpuCoreSet"]]], -"subspace_farmer_components":[["impl Sync for AuditingError",1,["subspace_farmer_components::auditing::AuditingError"]],["impl<'a, Sector> Sync for AuditResult<'a, Sector>
where\n Sector: Sync,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl Sync for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl Sync for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl Sync for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> Sync for PlotSectorOptions<'a, PosTable, PG>
where\n PG: Sync,\n <PosTable as Table>::Generator: Sync,
",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl Sync for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> Sync for DownloadSectorOptions<'a, PG>
where\n PG: Sync,
",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> Sync for EncodeSectorOptions<'a, PosTable>
where\n <PosTable as Table>::Generator: Sync,
",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl Sync for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> Sync for SolutionCandidates<'a, Sector>
where\n Sector: Sync,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl Sync for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl Sync for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl Sync for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl Sync for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> Sync for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl Sync for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl Sync for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl Sync for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl Sync for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> Sync for ReadAt<S, A>
where\n A: Sync,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> Sync for AsyncReadBytes<B>
where\n B: Sync,
",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> Sync for ReadAtOffset<'a, T>
where\n T: Sync,
",1,["subspace_farmer_components::ReadAtOffset"]],["impl Sync for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], +"subspace_farmer_components":[["impl Sync for AuditingError",1,["subspace_farmer_components::auditing::AuditingError"]],["impl<'a, Sector> Sync for AuditResult<'a, Sector>
where\n Sector: Sync,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl Sync for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl Sync for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl Sync for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> Sync for PlotSectorOptions<'a, PosTable, PG>
where\n PG: Sync,\n <PosTable as Table>::Generator: Sync,
",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl Sync for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> Sync for DownloadSectorOptions<'a, PG>
where\n PG: Sync,
",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> Sync for EncodeSectorOptions<'a, PosTable>
where\n <PosTable as Table>::Generator: Sync,
",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl Sync for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> Sync for SolutionCandidates<'a, Sector>
where\n Sector: Sync,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl Sync for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl Sync for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl Sync for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl Sync for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> Sync for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl Sync for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl Sync for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl Sync for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl Sync for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> Sync for ReadAt<S, A>
where\n A: Sync,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> Sync for AsyncReadBytes<B>
where\n B: Sync,
",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> Sync for ReadAtOffset<'a, T>
where\n T: Sync,
",1,["subspace_farmer_components::ReadAtOffset"]],["impl Sync for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], "subspace_malicious_operator":[["impl<CNetwork> Sync for DomainInstanceStarter<CNetwork>
where\n CNetwork: Sync + Send,
",1,["subspace_malicious_operator::malicious_domain_instance_starter::DomainInstanceStarter"]],["impl Sync for Cli",1,["subspace_malicious_operator::Cli"]],["impl Sync for DomainCli",1,["subspace_malicious_operator::DomainCli"]]], "subspace_metrics":[["impl Sync for RegistryAdapter",1,["subspace_metrics::RegistryAdapter"]],["impl Sync for metrics",1,["subspace_metrics::metrics"]]], "subspace_networking":[["impl Sync for PeerAddressRemovedEvent",1,["subspace_networking::behavior::persistent_parameters::PeerAddressRemovedEvent"]],["impl Sync for KnownPeersManagerConfig",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerConfig"]],["impl Sync for KnownPeersManagerPersistenceError",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerPersistenceError"]],["impl Sync for KnownPeersManager",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManager"]],["impl Sync for KademliaMode",1,["subspace_networking::constructor::KademliaMode"]],["impl<LocalRecordProvider> !Sync for Config<LocalRecordProvider>",1,["subspace_networking::constructor::Config"]],["impl Sync for CreationError",1,["subspace_networking::constructor::CreationError"]],["impl Sync for TopicSubscription",1,["subspace_networking::node::TopicSubscription"]],["impl Sync for GetClosestPeersError",1,["subspace_networking::node::GetClosestPeersError"]],["impl Sync for SubscribeError",1,["subspace_networking::node::SubscribeError"]],["impl Sync for SendRequestError",1,["subspace_networking::node::SendRequestError"]],["impl Sync for Node",1,["subspace_networking::node::Node"]],["impl<LocalRecordProvider> !Sync for NodeRunner<LocalRecordProvider>",1,["subspace_networking::node_runner::NodeRunner"]],["impl<Request> Sync for GenericRequestHandler<Request>",1,["subspace_networking::protocols::request_response::handlers::generic_request_handler::GenericRequestHandler"]],["impl Sync for PieceByIndexRequest",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexRequest"]],["impl Sync for PieceByIndexResponse",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexResponse"]],["impl Sync for SegmentHeaderRequest",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderRequest"]],["impl Sync for SegmentHeaderResponse",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderResponse"]],["impl Sync for PeerDiscovered",1,["subspace_networking::shared::PeerDiscovered"]],["impl Sync for MultihashCode",1,["subspace_networking::utils::multihash::MultihashCode"]],["impl Sync for NoPieceValidator",1,["subspace_networking::utils::piece_provider::NoPieceValidator"]],["impl Sync for RetryPolicy",1,["subspace_networking::utils::piece_provider::RetryPolicy"]],["impl<PV> Sync for PieceProvider<PV>
where\n PV: Sync,
",1,["subspace_networking::utils::piece_provider::PieceProvider"]],["impl<T> Sync for KeyWrapper<T>
where\n T: Sync,
",1,["subspace_networking::utils::unique_record_binary_heap::KeyWrapper"]],["impl<K> Sync for UniqueRecordBinaryHeap<K>
where\n K: Sync,
",1,["subspace_networking::utils::unique_record_binary_heap::UniqueRecordBinaryHeap"]],["impl Sync for SubspaceMetrics",1,["subspace_networking::utils::SubspaceMetrics"]]], diff --git a/trait.impl/core/ops/deref/trait.Deref.js b/trait.impl/core/ops/deref/trait.Deref.js index 919cfd7786..85a58b13cc 100644 --- a/trait.impl/core/ops/deref/trait.Deref.js +++ b/trait.impl/core/ops/deref/trait.Deref.js @@ -4,7 +4,7 @@ "sp_domains_fraud_proof":[["impl Deref for FraudProofExtension"]], "sp_subspace_mmr":[["impl Deref for SubspaceMmrExtension"]], "subspace_core_primitives":[["impl Deref for Commitment"],["impl Deref for Record"],["impl Deref for FlatPieces"],["impl Deref for PublicKey"],["impl Deref for PieceArray"],["impl Deref for RawRecord"],["impl Deref for RecordCommitment"],["impl Deref for Witness"],["impl Deref for ChunkWitness"],["impl Deref for ArchivedHistorySegment"],["impl Deref for PosProof"],["impl Deref for HistorySize"],["impl Deref for RewardSignature"],["impl Deref for PotCheckpoints"],["impl Deref for Randomness"],["impl Deref for PotOutput"],["impl Deref for Scalar"],["impl Deref for SegmentCommitment"],["impl Deref for RecordedHistorySegment"],["impl Deref for PotKey"],["impl Deref for PotSeed"],["impl Deref for PosSeed"],["impl Deref for Piece"],["impl Deref for SectorSlotChallenge"],["impl Deref for RecordWitness"]], -"subspace_farmer":[["impl Deref for PlottingThreadPoolsGuard"],["impl Deref for Identity"]], +"subspace_farmer":[["impl Deref for Identity"],["impl Deref for PlottingThreadPoolsGuard"]], "subspace_farmer_components":[["impl Deref for SectorMetadataChecksummed"]], "subspace_service":[["impl Deref for SubspaceConfiguration"]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/core/ops/drop/trait.Drop.js b/trait.impl/core/ops/drop/trait.Drop.js index b1912c4315..89a093b90b 100644 --- a/trait.impl/core/ops/drop/trait.Drop.js +++ b/trait.impl/core/ops/drop/trait.Drop.js @@ -1,5 +1,5 @@ (function() {var implementors = { -"subspace_farmer":[["impl Drop for PlottingThreadPoolsGuard"],["impl Drop for SingleDiskFarm"],["impl<T> Drop for AsyncJoinOnDrop<T>"]], +"subspace_farmer":[["impl Drop for SingleDiskFarm"],["impl Drop for PlottingThreadPoolsGuard"],["impl<T> Drop for AsyncJoinOnDrop<T>"]], "subspace_farmer_components":[["impl Drop for EncodedChunksUsed<'_>"]], "subspace_networking":[["impl Drop for TopicSubscription"],["impl Drop for KnownPeersManager"]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js index 26f0ff50d6..446b3da167 100644 --- a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js +++ b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js @@ -42,7 +42,7 @@ "subspace_core_primitives":[["impl<T> RefUnwindSafe for Blake3Checksummed<T>
where\n T: RefUnwindSafe,
",1,["subspace_core_primitives::checksum::Blake3Checksummed"]],["impl RefUnwindSafe for Polynomial",1,["subspace_core_primitives::crypto::kzg::Polynomial"]],["impl RefUnwindSafe for Commitment",1,["subspace_core_primitives::crypto::kzg::Commitment"]],["impl RefUnwindSafe for Witness",1,["subspace_core_primitives::crypto::kzg::Witness"]],["impl !RefUnwindSafe for Kzg",1,["subspace_core_primitives::crypto::kzg::Kzg"]],["impl RefUnwindSafe for Scalar",1,["subspace_core_primitives::crypto::Scalar"]],["impl RefUnwindSafe for BlockObject",1,["subspace_core_primitives::objects::BlockObject"]],["impl RefUnwindSafe for BlockObjectMapping",1,["subspace_core_primitives::objects::BlockObjectMapping"]],["impl RefUnwindSafe for PieceObject",1,["subspace_core_primitives::objects::PieceObject"]],["impl RefUnwindSafe for PieceObjectMapping",1,["subspace_core_primitives::objects::PieceObjectMapping"]],["impl RefUnwindSafe for GlobalObject",1,["subspace_core_primitives::objects::GlobalObject"]],["impl RefUnwindSafe for SBucket",1,["subspace_core_primitives::pieces::SBucket"]],["impl RefUnwindSafe for PieceIndex",1,["subspace_core_primitives::pieces::PieceIndex"]],["impl RefUnwindSafe for PieceOffset",1,["subspace_core_primitives::pieces::PieceOffset"]],["impl RefUnwindSafe for RawRecord",1,["subspace_core_primitives::pieces::RawRecord"]],["impl RefUnwindSafe for Record",1,["subspace_core_primitives::pieces::Record"]],["impl RefUnwindSafe for RecordCommitment",1,["subspace_core_primitives::pieces::RecordCommitment"]],["impl RefUnwindSafe for RecordWitness",1,["subspace_core_primitives::pieces::RecordWitness"]],["impl RefUnwindSafe for ChunkWitness",1,["subspace_core_primitives::pieces::ChunkWitness"]],["impl RefUnwindSafe for Piece",1,["subspace_core_primitives::pieces::Piece"]],["impl RefUnwindSafe for PieceArray",1,["subspace_core_primitives::pieces::PieceArray"]],["impl RefUnwindSafe for FlatPieces",1,["subspace_core_primitives::pieces::FlatPieces"]],["impl RefUnwindSafe for SegmentIndex",1,["subspace_core_primitives::segments::SegmentIndex"]],["impl RefUnwindSafe for SegmentCommitment",1,["subspace_core_primitives::segments::SegmentCommitment"]],["impl RefUnwindSafe for HistorySize",1,["subspace_core_primitives::segments::HistorySize"]],["impl RefUnwindSafe for RecordedHistorySegment",1,["subspace_core_primitives::segments::RecordedHistorySegment"]],["impl RefUnwindSafe for ArchivedHistorySegment",1,["subspace_core_primitives::segments::ArchivedHistorySegment"]],["impl RefUnwindSafe for Randomness",1,["subspace_core_primitives::Randomness"]],["impl RefUnwindSafe for PosSeed",1,["subspace_core_primitives::PosSeed"]],["impl RefUnwindSafe for PosProof",1,["subspace_core_primitives::PosProof"]],["impl RefUnwindSafe for PotKey",1,["subspace_core_primitives::PotKey"]],["impl RefUnwindSafe for PotSeed",1,["subspace_core_primitives::PotSeed"]],["impl RefUnwindSafe for PotOutput",1,["subspace_core_primitives::PotOutput"]],["impl RefUnwindSafe for PotCheckpoints",1,["subspace_core_primitives::PotCheckpoints"]],["impl RefUnwindSafe for PublicKey",1,["subspace_core_primitives::PublicKey"]],["impl RefUnwindSafe for RewardSignature",1,["subspace_core_primitives::RewardSignature"]],["impl RefUnwindSafe for ArchivedBlockProgress",1,["subspace_core_primitives::ArchivedBlockProgress"]],["impl RefUnwindSafe for LastArchivedBlock",1,["subspace_core_primitives::LastArchivedBlock"]],["impl RefUnwindSafe for SegmentHeader",1,["subspace_core_primitives::SegmentHeader"]],["impl<PublicKey, RewardAddress> RefUnwindSafe for Solution<PublicKey, RewardAddress>
where\n PublicKey: RefUnwindSafe,\n RewardAddress: RefUnwindSafe,
",1,["subspace_core_primitives::Solution"]],["impl RefUnwindSafe for U256",1,["subspace_core_primitives::U256"]],["impl RefUnwindSafe for SectorSlotChallenge",1,["subspace_core_primitives::SectorSlotChallenge"]],["impl RefUnwindSafe for SectorId",1,["subspace_core_primitives::SectorId"]],["impl<T> RefUnwindSafe for NonEmptyVec<T>
where\n T: RefUnwindSafe,
",1,["subspace_core_primitives::NonEmptyVec"]],["impl RefUnwindSafe for NonEmptyVecErr",1,["subspace_core_primitives::NonEmptyVecErr"]]], "subspace_erasure_coding":[["impl RefUnwindSafe for ErasureCoding",1,["subspace_erasure_coding::ErasureCoding"]]], "subspace_farmer":[["impl RefUnwindSafe for Identity",1,["subspace_farmer::identity::Identity"]],["impl !RefUnwindSafe for NodeRpcClient",1,["subspace_farmer::node_client::node_rpc_client::NodeRpcClient"]],["impl<NC> !RefUnwindSafe for CacheWorker<NC>",1,["subspace_farmer::piece_cache::CacheWorker"]],["impl !RefUnwindSafe for PieceCache",1,["subspace_farmer::piece_cache::PieceCache"]],["impl RefUnwindSafe for RayonFiles",1,["subspace_farmer::single_disk_farm::farming::rayon_files::RayonFiles"]],["impl RefUnwindSafe for AuditingDetails",1,["subspace_farmer::single_disk_farm::farming::AuditingDetails"]],["impl RefUnwindSafe for ProvingResult",1,["subspace_farmer::single_disk_farm::farming::ProvingResult"]],["impl RefUnwindSafe for ProvingDetails",1,["subspace_farmer::single_disk_farm::farming::ProvingDetails"]],["impl !RefUnwindSafe for FarmingNotification",1,["subspace_farmer::single_disk_farm::farming::FarmingNotification"]],["impl RefUnwindSafe for DecodedFarmingError",1,["subspace_farmer::single_disk_farm::farming::DecodedFarmingError"]],["impl !RefUnwindSafe for FarmingError",1,["subspace_farmer::single_disk_farm::farming::FarmingError"]],["impl<'a, PosTable> !RefUnwindSafe for PlotAuditOptions<'a, PosTable>",1,["subspace_farmer::single_disk_farm::farming::PlotAuditOptions"]],["impl<Plot> RefUnwindSafe for PlotAudit<Plot>
where\n Plot: RefUnwindSafe,
",1,["subspace_farmer::single_disk_farm::farming::PlotAudit"]],["impl !RefUnwindSafe for DiskPieceCacheError",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"]],["impl RefUnwindSafe for Offset",1,["subspace_farmer::single_disk_farm::piece_cache::Offset"]],["impl RefUnwindSafe for DiskPieceCache",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCache"]],["impl !RefUnwindSafe for PieceReader",1,["subspace_farmer::single_disk_farm::piece_reader::PieceReader"]],["impl RefUnwindSafe for SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorPlottingDetails"]],["impl RefUnwindSafe for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorExpirationDetails"]],["impl !RefUnwindSafe for PlottingError",1,["subspace_farmer::single_disk_farm::plotting::PlottingError"]],["impl RefUnwindSafe for SingleDiskFarmId",1,["subspace_farmer::single_disk_farm::SingleDiskFarmId"]],["impl RefUnwindSafe for SingleDiskFarmInfoLock",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock"]],["impl RefUnwindSafe for SingleDiskFarmInfo",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfo"]],["impl !RefUnwindSafe for SingleDiskFarmSummary",1,["subspace_farmer::single_disk_farm::SingleDiskFarmSummary"]],["impl<NC, PG> !RefUnwindSafe for SingleDiskFarmOptions<NC, PG>",1,["subspace_farmer::single_disk_farm::SingleDiskFarmOptions"]],["impl !RefUnwindSafe for SingleDiskFarmError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmError"]],["impl !RefUnwindSafe for SingleDiskFarmScrubError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"]],["impl !RefUnwindSafe for BackgroundTaskError",1,["subspace_farmer::single_disk_farm::BackgroundTaskError"]],["impl RefUnwindSafe for SectorUpdate",1,["subspace_farmer::single_disk_farm::SectorUpdate"]],["impl !RefUnwindSafe for SingleDiskFarm",1,["subspace_farmer::single_disk_farm::SingleDiskFarm"]],["impl !RefUnwindSafe for PlottingThreadPoolPair",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolPair"]],["impl !RefUnwindSafe for PlottingThreadPoolsGuard",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolsGuard"]],["impl !RefUnwindSafe for PlottingThreadPoolManager",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolManager"]],["impl<PV, NC> !RefUnwindSafe for FarmerPieceGetter<PV, NC>",1,["subspace_farmer::utils::farmer_piece_getter::FarmerPieceGetter"]],["impl<NC> !RefUnwindSafe for SegmentCommitmentPieceValidator<NC>",1,["subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator"]],["impl !RefUnwindSafe for ReadersAndPieces",1,["subspace_farmer::utils::readers_and_pieces::ReadersAndPieces"]],["impl RefUnwindSafe for Ss58ParsingError",1,["subspace_farmer::utils::ss58::Ss58ParsingError"]],["impl<T> RefUnwindSafe for AsyncJoinOnDrop<T>",1,["subspace_farmer::utils::AsyncJoinOnDrop"]],["impl RefUnwindSafe for CpuCoreSet",1,["subspace_farmer::utils::CpuCoreSet"]]], -"subspace_farmer_components":[["impl !RefUnwindSafe for AuditingError",1,["subspace_farmer_components::auditing::AuditingError"]],["impl<'a, Sector> RefUnwindSafe for AuditResult<'a, Sector>
where\n Sector: RefUnwindSafe,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl RefUnwindSafe for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl RefUnwindSafe for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl !RefUnwindSafe for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> !RefUnwindSafe for PlotSectorOptions<'a, PosTable, PG>",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl RefUnwindSafe for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> !RefUnwindSafe for DownloadSectorOptions<'a, PG>",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> RefUnwindSafe for EncodeSectorOptions<'a, PosTable>
where\n <PosTable as Table>::Generator: RefUnwindSafe,
",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl !RefUnwindSafe for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> RefUnwindSafe for SolutionCandidates<'a, Sector>
where\n Sector: RefUnwindSafe,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl !RefUnwindSafe for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl RefUnwindSafe for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl RefUnwindSafe for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl RefUnwindSafe for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> RefUnwindSafe for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl RefUnwindSafe for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl RefUnwindSafe for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl RefUnwindSafe for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl RefUnwindSafe for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> RefUnwindSafe for ReadAt<S, A>
where\n A: RefUnwindSafe,\n S: RefUnwindSafe,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> RefUnwindSafe for AsyncReadBytes<B>
where\n B: RefUnwindSafe,
",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> RefUnwindSafe for ReadAtOffset<'a, T>
where\n T: RefUnwindSafe,
",1,["subspace_farmer_components::ReadAtOffset"]],["impl RefUnwindSafe for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], +"subspace_farmer_components":[["impl !RefUnwindSafe for AuditingError",1,["subspace_farmer_components::auditing::AuditingError"]],["impl<'a, Sector> RefUnwindSafe for AuditResult<'a, Sector>
where\n Sector: RefUnwindSafe,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl RefUnwindSafe for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl RefUnwindSafe for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl !RefUnwindSafe for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> !RefUnwindSafe for PlotSectorOptions<'a, PosTable, PG>",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl RefUnwindSafe for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> !RefUnwindSafe for DownloadSectorOptions<'a, PG>",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> RefUnwindSafe for EncodeSectorOptions<'a, PosTable>
where\n <PosTable as Table>::Generator: RefUnwindSafe,
",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl !RefUnwindSafe for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> RefUnwindSafe for SolutionCandidates<'a, Sector>
where\n Sector: RefUnwindSafe,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl !RefUnwindSafe for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl RefUnwindSafe for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl RefUnwindSafe for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl RefUnwindSafe for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> RefUnwindSafe for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl RefUnwindSafe for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl RefUnwindSafe for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl RefUnwindSafe for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl RefUnwindSafe for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> RefUnwindSafe for ReadAt<S, A>
where\n A: RefUnwindSafe,\n S: RefUnwindSafe,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> RefUnwindSafe for AsyncReadBytes<B>
where\n B: RefUnwindSafe,
",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> RefUnwindSafe for ReadAtOffset<'a, T>
where\n T: RefUnwindSafe,
",1,["subspace_farmer_components::ReadAtOffset"]],["impl RefUnwindSafe for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], "subspace_malicious_operator":[["impl<CNetwork> !RefUnwindSafe for DomainInstanceStarter<CNetwork>",1,["subspace_malicious_operator::malicious_domain_instance_starter::DomainInstanceStarter"]],["impl RefUnwindSafe for Cli",1,["subspace_malicious_operator::Cli"]],["impl RefUnwindSafe for DomainCli",1,["subspace_malicious_operator::DomainCli"]]], "subspace_metrics":[["impl !RefUnwindSafe for RegistryAdapter",1,["subspace_metrics::RegistryAdapter"]],["impl RefUnwindSafe for metrics",1,["subspace_metrics::metrics"]]], "subspace_networking":[["impl RefUnwindSafe for PeerAddressRemovedEvent",1,["subspace_networking::behavior::persistent_parameters::PeerAddressRemovedEvent"]],["impl RefUnwindSafe for KnownPeersManagerConfig",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerConfig"]],["impl !RefUnwindSafe for KnownPeersManagerPersistenceError",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerPersistenceError"]],["impl !RefUnwindSafe for KnownPeersManager",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManager"]],["impl RefUnwindSafe for KademliaMode",1,["subspace_networking::constructor::KademliaMode"]],["impl<LocalRecordProvider> !RefUnwindSafe for Config<LocalRecordProvider>",1,["subspace_networking::constructor::Config"]],["impl !RefUnwindSafe for CreationError",1,["subspace_networking::constructor::CreationError"]],["impl !RefUnwindSafe for TopicSubscription",1,["subspace_networking::node::TopicSubscription"]],["impl RefUnwindSafe for GetClosestPeersError",1,["subspace_networking::node::GetClosestPeersError"]],["impl !RefUnwindSafe for SubscribeError",1,["subspace_networking::node::SubscribeError"]],["impl !RefUnwindSafe for SendRequestError",1,["subspace_networking::node::SendRequestError"]],["impl !RefUnwindSafe for Node",1,["subspace_networking::node::Node"]],["impl<LocalRecordProvider> !RefUnwindSafe for NodeRunner<LocalRecordProvider>",1,["subspace_networking::node_runner::NodeRunner"]],["impl<Request> !RefUnwindSafe for GenericRequestHandler<Request>",1,["subspace_networking::protocols::request_response::handlers::generic_request_handler::GenericRequestHandler"]],["impl RefUnwindSafe for PieceByIndexRequest",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexRequest"]],["impl RefUnwindSafe for PieceByIndexResponse",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexResponse"]],["impl RefUnwindSafe for SegmentHeaderRequest",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderRequest"]],["impl RefUnwindSafe for SegmentHeaderResponse",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderResponse"]],["impl RefUnwindSafe for PeerDiscovered",1,["subspace_networking::shared::PeerDiscovered"]],["impl RefUnwindSafe for MultihashCode",1,["subspace_networking::utils::multihash::MultihashCode"]],["impl RefUnwindSafe for NoPieceValidator",1,["subspace_networking::utils::piece_provider::NoPieceValidator"]],["impl RefUnwindSafe for RetryPolicy",1,["subspace_networking::utils::piece_provider::RetryPolicy"]],["impl<PV> !RefUnwindSafe for PieceProvider<PV>",1,["subspace_networking::utils::piece_provider::PieceProvider"]],["impl<T> RefUnwindSafe for KeyWrapper<T>
where\n T: RefUnwindSafe,
",1,["subspace_networking::utils::unique_record_binary_heap::KeyWrapper"]],["impl<K> RefUnwindSafe for UniqueRecordBinaryHeap<K>
where\n K: RefUnwindSafe,
",1,["subspace_networking::utils::unique_record_binary_heap::UniqueRecordBinaryHeap"]],["impl RefUnwindSafe for SubspaceMetrics",1,["subspace_networking::utils::SubspaceMetrics"]]], diff --git a/trait.impl/parity_scale_codec/codec/trait.Decode.js b/trait.impl/parity_scale_codec/codec/trait.Decode.js index 4fb88141f1..aacec14eef 100644 --- a/trait.impl/parity_scale_codec/codec/trait.Decode.js +++ b/trait.impl/parity_scale_codec/codec/trait.Decode.js @@ -21,14 +21,14 @@ "pallet_transporter":[["impl<T> Decode for Error<T>"],["impl<Balance> Decode for Transfer<Balance>
where\n Balance: Decode,
"],["impl<T: Config> Decode for Event<T>
where\n <<T as Config>::Sender as Sender<<T as Config>::AccountId>>::MessageId: Decode,
"],["impl<T: Config> Decode for Call<T>"],["impl Decode for Location"]], "sp_block_fees":[["impl Decode for InherentError"]], "sp_consensus_subspace":[["impl Decode for WrappedSolution"],["impl Decode for PotParametersChange"],["impl Decode for SubspaceJustification"],["impl Decode for InherentType"],["impl Decode for PotNextSlotInput"],["impl Decode for SolutionRanges"],["impl<Number, Hash, RewardAddress> Decode for Vote<Number, Hash, RewardAddress>
where\n Number: Decode,\n Hash: Decode,\n Solution<FarmerPublicKey, RewardAddress>: Decode,
"],["impl Decode for InherentError"],["impl<Offender> Decode for OffenceDetails<Offender>
where\n Offender: Decode,
"],["impl Decode for PreDigestPotInfo"],["impl<'a> Decode for WrappedVerifySolutionParams<'a>"],["impl Decode for ChainConstants"],["impl Decode for WrappedPotOutput"],["impl<PublicKey, RewardAddress> Decode for PreDigest<PublicKey, RewardAddress>
where\n Solution<PublicKey, RewardAddress>: Decode,
"],["impl<Number, Hash, RewardAddress> Decode for SignedVote<Number, Hash, RewardAddress>
where\n Vote<Number, Hash, RewardAddress>: Decode,
"],["impl Decode for PotParameters"]], -"sp_domains":[["impl Decode for InvalidReceipt"],["impl Decode for ReceiptValidity"],["impl Decode for Witness"],["impl<AccountId: Ord> Decode for OperatorAllowList<AccountId>
where\n BTreeSet<AccountId>: Decode,
"],["impl<Balance> Decode for BundleProducerElectionParams<Balance>
where\n Balance: Decode,
"],["impl<Hash> Decode for BundleDigest<Hash>
where\n Hash: Decode,
"],["impl Decode for StorageData"],["impl Decode for ExtrinsicDigest"],["impl<Extrinsic, Number, Hash, DomainHeader: HeaderT, Balance> Decode for Bundle<Extrinsic, Number, Hash, DomainHeader, Balance>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: Decode,\n Vec<Extrinsic>: Decode,
"],["impl<AccountId> Decode for GenesisDomain<AccountId>
where\n AccountId: Decode + Ord,\n OperatorAllowList<AccountId>: Decode,
"],["impl Decode for RawGenesis"],["impl<Number, Hash, DomainHeader: HeaderT, Balance> Decode for BundleHeader<Number, Hash, DomainHeader, Balance>
where\n ProofOfElection<Hash>: Decode,\n ExecutionReceipt<Number, Hash, HeaderNumberFor<DomainHeader>, HeaderHashFor<DomainHeader>, Balance>: Decode,\n HeaderHashFor<DomainHeader>: Decode,
"],["impl Decode for ProofOfElectionError"],["impl<CHash> Decode for ProofOfElection<CHash>
where\n CHash: Decode,
"],["impl Decode for DomainBlockLimit"],["impl Decode for StorageKey"],["impl Decode for VerificationError"],["impl Decode for RuntimeType"],["impl Decode for DomainInstanceData"],["impl<Hash> Decode for InboxedBundle<Hash>
where\n BundleValidity<Hash>: Decode,\n Hash: Decode,
"],["impl<Number, Hash, DomainHeader: HeaderT, Balance> Decode for SealedBundleHeader<Number, Hash, DomainHeader, Balance>
where\n BundleHeader<Number, Hash, DomainHeader, Balance>: Decode,
"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> Decode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Decode,\n DomainHash: Decode,\n Number: Decode,\n Hash: Decode,\n Vec<InboxedBundle<DomainHash>>: Decode,\n Vec<DomainHash>: Decode,\n BlockFees<Balance>: Decode,
"],["impl Decode for StakingHoldIdentifier"],["impl Decode for DomainsHoldIdentifier"],["impl Decode for DomainId"],["impl Decode for DomainDigestItem"],["impl Decode for InvalidBundleType"],["impl<Hash> Decode for BundleValidity<Hash>
where\n Hash: Decode,
"]], +"sp_domains":[["impl Decode for InvalidReceipt"],["impl Decode for ReceiptValidity"],["impl Decode for Witness"],["impl<AccountId: Ord> Decode for OperatorAllowList<AccountId>
where\n BTreeSet<AccountId>: Decode,
"],["impl<Balance> Decode for BundleProducerElectionParams<Balance>
where\n Balance: Decode,
"],["impl<Hash> Decode for BundleDigest<Hash>
where\n Hash: Decode,
"],["impl Decode for StorageData"],["impl Decode for ExtrinsicDigest"],["impl<Extrinsic, Number, Hash, DomainHeader: HeaderT, Balance> Decode for Bundle<Extrinsic, Number, Hash, DomainHeader, Balance>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: Decode,\n Vec<Extrinsic>: Decode,
"],["impl<AccountId> Decode for GenesisDomain<AccountId>
where\n AccountId: Decode + Ord,\n OperatorAllowList<AccountId>: Decode,
"],["impl Decode for RawGenesis"],["impl<Number, Hash, DomainHeader: HeaderT, Balance> Decode for BundleHeader<Number, Hash, DomainHeader, Balance>
where\n ProofOfElection<Hash>: Decode,\n ExecutionReceipt<Number, Hash, HeaderNumberFor<DomainHeader>, HeaderHashFor<DomainHeader>, Balance>: Decode,\n HeaderHashFor<DomainHeader>: Decode,
"],["impl Decode for ProofOfElectionError"],["impl<CHash> Decode for ProofOfElection<CHash>
where\n CHash: Decode,
"],["impl Decode for DomainBlockLimit"],["impl Decode for StorageKey"],["impl Decode for VerificationError"],["impl Decode for RuntimeType"],["impl Decode for DomainInstanceData"],["impl<Hash> Decode for InboxedBundle<Hash>
where\n BundleValidity<Hash>: Decode,\n Hash: Decode,
"],["impl<Number, Hash, DomainHeader: HeaderT, Balance> Decode for SealedBundleHeader<Number, Hash, DomainHeader, Balance>
where\n BundleHeader<Number, Hash, DomainHeader, Balance>: Decode,
"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> Decode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Decode,\n DomainHash: Decode,\n Number: Decode,\n Hash: Decode,\n Vec<InboxedBundle<DomainHash>>: Decode,\n Vec<DomainHash>: Decode,\n BlockFees<Balance>: Decode,
"],["impl Decode for StakingHoldIdentifier"],["impl Decode for DomainsHoldIdentifier"],["impl Decode for DomainId"],["impl Decode for DomainDigestItem"],["impl Decode for InvalidBundleType"],["impl<Hash> Decode for BundleValidity<Hash>
where\n Hash: Decode,
"]], "sp_domains_fraud_proof":[["impl Decode for ValidBundleDigest"],["impl Decode for FraudProofVerificationInfoRequest"],["impl Decode for SetCodeExtrinsic"],["impl Decode for ExecutionPhase"],["impl Decode for ApplyExtrinsicMismatch"],["impl<ReceiptHash> Decode for InvalidBlockFeesProof<ReceiptHash>
where\n ReceiptHash: Decode,
"],["impl<DomainHash> Decode for InvalidTransactionProof<DomainHash>
where\n DomainHash: Decode,
"],["impl<ReceiptHash> Decode for ValidBundleProof<ReceiptHash>
where\n ReceiptHash: Decode,
"],["impl<Number, Hash, DomainHeader: HeaderT> Decode for BundleEquivocationProof<Number, Hash, DomainHeader>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: Decode,
"],["impl<ReceiptHash> Decode for InvalidExtrinsicsRootProof<ReceiptHash>
where\n ReceiptHash: Decode,
"],["impl<ReceiptHash> Decode for InvalidBundlesFraudProof<ReceiptHash>
where\n ReceiptHash: Decode,
"],["impl<ReceiptHash> Decode for InvalidStateTransitionProof<ReceiptHash>
where\n ReceiptHash: Decode,
"],["impl<ReceiptHash> Decode for ImproperTransactionSortitionProof<ReceiptHash>
where\n ReceiptHash: Decode,
"],["impl Decode for FraudProofVerificationInfoResponse"],["impl Decode for FinalizeBlockMismatch"],["impl<Number, Hash, DomainHeader: HeaderT> Decode for FraudProof<Number, Hash, DomainHeader>
where\n InvalidStateTransitionProof<HeaderHashFor<DomainHeader>>: Decode,\n InvalidTransactionProof<HeaderHashFor<DomainHeader>>: Decode,\n BundleEquivocationProof<Number, Hash, DomainHeader>: Decode,\n ImproperTransactionSortitionProof<HeaderHashFor<DomainHeader>>: Decode,\n InvalidBlockFeesProof<HeaderHashFor<DomainHeader>>: Decode,\n InvalidExtrinsicsRootProof<HeaderHashFor<DomainHeader>>: Decode,\n ValidBundleProof<HeaderHashFor<DomainHeader>>: Decode,\n InvalidDomainBlockHashProof<HeaderHashFor<DomainHeader>>: Decode,\n InvalidBundlesFraudProof<HeaderHashFor<DomainHeader>>: Decode,\n HeaderHashFor<DomainHeader>: Decode,
"],["impl<ReceiptHash> Decode for InvalidDomainBlockHashProof<ReceiptHash>
where\n ReceiptHash: Decode,
"]], "sp_executive":[["impl Decode for InherentError"],["impl Decode for InherentType"]], "sp_messenger":[["impl Decode for EndpointRequest"],["impl<Balance> Decode for FeeModel<Balance>
where\n Balance: Decode,
"],["impl Decode for MessageWeightTag"],["impl<BlockNumber, BlockHash, StateRoot> Decode for ExtractedStateRootsFromProof<BlockNumber, BlockHash, StateRoot>
where\n BlockInfo<BlockNumber, BlockHash>: Decode,\n StateRoot: Decode,\n Option<(DomainId, BlockInfo<BlockNumber, BlockHash>, StateRoot)>: Decode,
"],["impl<Number, Hash> Decode for BlockInfo<Number, Hash>
where\n Number: Decode,\n Hash: Decode,
"],["impl<Balance> Decode for VersionedPayload<Balance>
where\n Payload<Balance>: Decode,
"],["impl<BlockNumber, BlockHash, StateRoot> Decode for CrossDomainMessage<BlockNumber, BlockHash, StateRoot>
where\n Proof<BlockNumber, BlockHash, StateRoot>: Decode,
"],["impl<Balance> Decode for ProtocolMessageRequest<Balance>
where\n InitiateChannelParams<Balance>: Decode,
"],["impl<Balance> Decode for Message<Balance>
where\n VersionedPayload<Balance>: Decode,
"],["impl<Balance> Decode for InitiateChannelParams<Balance>
where\n FeeModel<Balance>: Decode,
"],["impl Decode for ChainId"],["impl Decode for Endpoint"],["impl<Request, Response> Decode for RequestResponse<Request, Response>
where\n Request: Decode,\n Response: Decode,
"],["impl Decode for BlockMessageWithStorageKey"],["impl<BlockNumber, BlockHash, StateRoot> Decode for Proof<BlockNumber, BlockHash, StateRoot>
where\n BlockInfo<BlockNumber, BlockHash>: Decode,\n StateRoot: Decode,\n Option<(BlockInfo<BlockNumber, BlockHash>, StorageProof)>: Decode,
"],["impl<Balance> Decode for Payload<Balance>
where\n RequestResponse<ProtocolMessageRequest<Balance>, ProtocolMessageResponse>: Decode,
"],["impl Decode for BlockMessagesWithStorageKey"]], "sp_subspace_mmr":[["impl<MmrRootHash> Decode for MmrDigestItem<MmrRootHash>
where\n MmrRootHash: Decode + Codec,
"],["impl<BlockNumber, Hash> Decode for LeafDataV0<BlockNumber, Hash>
where\n BlockNumber: Decode,\n Hash: Decode,
"],["impl<BlockNumber, Hash> Decode for MmrLeaf<BlockNumber, Hash>
where\n LeafDataV0<BlockNumber, Hash>: Decode,
"]], "subspace_archiving":[["impl Decode for SegmentItem"],["impl Decode for Segment"],["impl Decode for NewArchivedSegment"]], "subspace_core_primitives":[["impl Decode for RecordWitness"],["impl Decode for PosProof"],["impl Decode for LastArchivedBlock"],["impl Decode for PieceObjectMapping"],["impl Decode for FlatPieces"],["impl Decode for BlockObjectMapping"],["impl Decode for SegmentIndex"],["impl Decode for Scalar"],["impl Decode for ArchivedBlockProgress"],["impl Decode for PieceObject"],["impl Decode for HistorySize"],["impl Decode for PieceIndex"],["impl<T> Decode for NonEmptyVec<T>
where\n Vec<T>: Decode,
"],["impl<PublicKey, RewardAddress> Decode for Solution<PublicKey, RewardAddress>
where\n PublicKey: Decode,\n RewardAddress: Decode,
"],["impl Decode for Randomness"],["impl Decode for PieceArray"],["impl Decode for SegmentHeader"],["impl Decode for PotOutput"],["impl Decode for SBucket"],["impl Decode for RewardSignature"],["impl Decode for BlockObject"],["impl Decode for ChunkWitness"],["impl<T> Decode for Blake3Checksummed<T>
where\n T: Decode,
"],["impl Decode for PieceOffset"],["impl Decode for SectorId"],["impl Decode for GlobalObject"],["impl Decode for SegmentCommitment"],["impl Decode for Piece"],["impl Decode for PublicKey"],["impl Decode for U256"],["impl Decode for PotCheckpoints"],["impl Decode for PotKey"],["impl Decode for PotSeed"],["impl Decode for RecordCommitment"],["impl Decode for ArchivedHistorySegment"]], -"subspace_farmer":[["impl Decode for AuditingDetails"],["impl Decode for FarmingError"],["impl Decode for ProvingDetails"],["impl Decode for SectorExpirationDetails"],["impl Decode for DecodedFarmingError"],["impl Decode for SectorUpdate"],["impl Decode for SectorPlottingDetails"],["impl Decode for FarmingNotification"],["impl Decode for ProvingResult"]], +"subspace_farmer":[["impl Decode for DecodedFarmingError"],["impl Decode for SectorPlottingDetails"],["impl Decode for SectorUpdate"],["impl Decode for ProvingDetails"],["impl Decode for FarmingError"],["impl Decode for ProvingResult"],["impl Decode for SectorExpirationDetails"],["impl Decode for FarmingNotification"],["impl Decode for AuditingDetails"]], "subspace_farmer_components":[["impl Decode for SectorMetadata"],["impl Decode for SectorMetadataChecksummed"],["impl Decode for PlottedSector"]], "subspace_networking":[["impl Decode for SegmentHeaderRequest"],["impl Decode for PieceByIndexRequest"],["impl Decode for SegmentHeaderResponse"],["impl Decode for PieceByIndexResponse"]], "subspace_runtime":[["impl Decode for DisablePallets"],["impl Decode for HoldIdentifier"],["impl Decode for OriginCaller"],["impl Decode for RuntimeEvent"],["impl Decode for RuntimeSlashReason"],["impl Decode for RuntimeCall"],["impl Decode for RuntimeError"],["impl Decode for RuntimeHoldReason"],["impl Decode for RuntimeTask"],["impl Decode for RuntimeFreezeReason"],["impl Decode for CheckStorageAccess"],["impl Decode for SessionKeys"],["impl Decode for RuntimeLockId"]], diff --git a/trait.impl/parity_scale_codec/codec/trait.Encode.js b/trait.impl/parity_scale_codec/codec/trait.Encode.js index 70b146cda3..9726c4a792 100644 --- a/trait.impl/parity_scale_codec/codec/trait.Encode.js +++ b/trait.impl/parity_scale_codec/codec/trait.Encode.js @@ -21,14 +21,14 @@ "pallet_transporter":[["impl<T: Config> Encode for Call<T>"],["impl<T: Config> Encode for Event<T>
where\n <<T as Config>::Sender as Sender<<T as Config>::AccountId>>::MessageId: Encode,
"],["impl<T> Encode for Error<T>"],["impl<Balance> Encode for Transfer<Balance>
where\n Balance: Encode,
"],["impl Encode for Location"]], "sp_block_fees":[["impl Encode for InherentError"]], "sp_consensus_subspace":[["impl<Offender> Encode for OffenceDetails<Offender>
where\n Offender: Encode,
"],["impl Encode for PotParameters"],["impl Encode for PotNextSlotInput"],["impl Encode for InherentError"],["impl Encode for SolutionRanges"],["impl Encode for PreDigestPotInfo"],["impl Encode for WrappedSolution"],["impl Encode for InherentType"],["impl<Number, Hash, RewardAddress> Encode for SignedVote<Number, Hash, RewardAddress>
where\n Vote<Number, Hash, RewardAddress>: Encode,
"],["impl Encode for WrappedPotOutput"],["impl<PublicKey, RewardAddress> Encode for PreDigest<PublicKey, RewardAddress>
where\n Solution<PublicKey, RewardAddress>: Encode,
"],["impl<'a> Encode for WrappedVerifySolutionParams<'a>"],["impl Encode for PotParametersChange"],["impl Encode for SubspaceJustification"],["impl Encode for ChainConstants"],["impl<Number, Hash, RewardAddress> Encode for Vote<Number, Hash, RewardAddress>
where\n Number: Encode,\n Hash: Encode,\n Solution<FarmerPublicKey, RewardAddress>: Encode,
"]], -"sp_domains":[["impl Encode for InvalidReceipt"],["impl Encode for StorageData"],["impl Encode for InvalidBundleType"],["impl Encode for ExtrinsicDigest"],["impl<AccountId> Encode for GenesisDomain<AccountId>
where\n AccountId: Encode + Ord,\n OperatorAllowList<AccountId>: Encode,
"],["impl Encode for StakingHoldIdentifier"],["impl<Number, Hash, DomainHeader: HeaderT, Balance> Encode for BundleHeader<Number, Hash, DomainHeader, Balance>
where\n ProofOfElection<Hash>: Encode,\n ExecutionReceipt<Number, Hash, HeaderNumberFor<DomainHeader>, HeaderHashFor<DomainHeader>, Balance>: Encode,\n HeaderHashFor<DomainHeader>: Encode,
"],["impl Encode for DomainId"],["impl<CHash> Encode for ProofOfElection<CHash>
where\n CHash: Encode,
"],["impl<Hash> Encode for BundleDigest<Hash>
where\n Hash: Encode,
"],["impl Encode for DomainInstanceData"],["impl Encode for DomainDigestItem"],["impl<Balance> Encode for BundleProducerElectionParams<Balance>
where\n Balance: Encode,
"],["impl<Hash> Encode for InboxedBundle<Hash>
where\n BundleValidity<Hash>: Encode,\n Hash: Encode,
"],["impl<Number, Hash, DomainHeader: HeaderT, Balance> Encode for SealedBundleHeader<Number, Hash, DomainHeader, Balance>
where\n BundleHeader<Number, Hash, DomainHeader, Balance>: Encode,
"],["impl<Hash> Encode for BundleValidity<Hash>
where\n Hash: Encode,
"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> Encode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,
"],["impl Encode for ProofOfElectionError"],["impl Encode for StorageKey"],["impl<Extrinsic, Number, Hash, DomainHeader: HeaderT, Balance> Encode for Bundle<Extrinsic, Number, Hash, DomainHeader, Balance>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: Encode,\n Vec<Extrinsic>: Encode,
"],["impl Encode for RuntimeType"],["impl Encode for DomainBlockLimit"],["impl Encode for RawGenesis"],["impl Encode for ReceiptValidity"],["impl Encode for VerificationError"],["impl Encode for Witness"],["impl<AccountId: Ord> Encode for OperatorAllowList<AccountId>
where\n BTreeSet<AccountId>: Encode,
"],["impl Encode for DomainsHoldIdentifier"]], +"sp_domains":[["impl Encode for InvalidReceipt"],["impl Encode for StorageData"],["impl Encode for InvalidBundleType"],["impl Encode for ExtrinsicDigest"],["impl<AccountId> Encode for GenesisDomain<AccountId>
where\n AccountId: Encode + Ord,\n OperatorAllowList<AccountId>: Encode,
"],["impl Encode for StakingHoldIdentifier"],["impl<Number, Hash, DomainHeader: HeaderT, Balance> Encode for BundleHeader<Number, Hash, DomainHeader, Balance>
where\n ProofOfElection<Hash>: Encode,\n ExecutionReceipt<Number, Hash, HeaderNumberFor<DomainHeader>, HeaderHashFor<DomainHeader>, Balance>: Encode,\n HeaderHashFor<DomainHeader>: Encode,
"],["impl Encode for DomainId"],["impl<CHash> Encode for ProofOfElection<CHash>
where\n CHash: Encode,
"],["impl<Hash> Encode for BundleDigest<Hash>
where\n Hash: Encode,
"],["impl Encode for DomainInstanceData"],["impl Encode for DomainDigestItem"],["impl<Balance> Encode for BundleProducerElectionParams<Balance>
where\n Balance: Encode,
"],["impl<Hash> Encode for InboxedBundle<Hash>
where\n BundleValidity<Hash>: Encode,\n Hash: Encode,
"],["impl<Number, Hash, DomainHeader: HeaderT, Balance> Encode for SealedBundleHeader<Number, Hash, DomainHeader, Balance>
where\n BundleHeader<Number, Hash, DomainHeader, Balance>: Encode,
"],["impl<Hash> Encode for BundleValidity<Hash>
where\n Hash: Encode,
"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> Encode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,
"],["impl Encode for ProofOfElectionError"],["impl Encode for StorageKey"],["impl<Extrinsic, Number, Hash, DomainHeader: HeaderT, Balance> Encode for Bundle<Extrinsic, Number, Hash, DomainHeader, Balance>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: Encode,\n Vec<Extrinsic>: Encode,
"],["impl Encode for RuntimeType"],["impl Encode for DomainBlockLimit"],["impl Encode for RawGenesis"],["impl Encode for ReceiptValidity"],["impl Encode for VerificationError"],["impl Encode for Witness"],["impl<AccountId: Ord> Encode for OperatorAllowList<AccountId>
where\n BTreeSet<AccountId>: Encode,
"],["impl Encode for DomainsHoldIdentifier"]], "sp_domains_fraud_proof":[["impl<ReceiptHash> Encode for InvalidBundlesFraudProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl<Number, Hash, DomainHeader: HeaderT> Encode for FraudProof<Number, Hash, DomainHeader>
where\n InvalidStateTransitionProof<HeaderHashFor<DomainHeader>>: Encode,\n InvalidTransactionProof<HeaderHashFor<DomainHeader>>: Encode,\n BundleEquivocationProof<Number, Hash, DomainHeader>: Encode,\n ImproperTransactionSortitionProof<HeaderHashFor<DomainHeader>>: Encode,\n InvalidBlockFeesProof<HeaderHashFor<DomainHeader>>: Encode,\n InvalidExtrinsicsRootProof<HeaderHashFor<DomainHeader>>: Encode,\n ValidBundleProof<HeaderHashFor<DomainHeader>>: Encode,\n InvalidDomainBlockHashProof<HeaderHashFor<DomainHeader>>: Encode,\n InvalidBundlesFraudProof<HeaderHashFor<DomainHeader>>: Encode,\n HeaderHashFor<DomainHeader>: Encode,
"],["impl<ReceiptHash> Encode for InvalidBlockFeesProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl<Number, Hash, DomainHeader: HeaderT> Encode for BundleEquivocationProof<Number, Hash, DomainHeader>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: Encode,
"],["impl<ReceiptHash> Encode for InvalidDomainBlockHashProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl Encode for FraudProofVerificationInfoRequest"],["impl Encode for FinalizeBlockMismatch"],["impl<DomainHash> Encode for InvalidTransactionProof<DomainHash>
where\n DomainHash: Encode,
"],["impl Encode for ValidBundleDigest"],["impl Encode for FraudProofVerificationInfoResponse"],["impl<ReceiptHash> Encode for InvalidStateTransitionProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl<ReceiptHash> Encode for ValidBundleProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl Encode for ApplyExtrinsicMismatch"],["impl Encode for SetCodeExtrinsic"],["impl Encode for ExecutionPhase"],["impl<ReceiptHash> Encode for ImproperTransactionSortitionProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl<ReceiptHash> Encode for InvalidExtrinsicsRootProof<ReceiptHash>
where\n ReceiptHash: Encode,
"]], "sp_executive":[["impl Encode for InherentType"],["impl Encode for InherentError"]], "sp_messenger":[["impl<Number, Hash> Encode for BlockInfo<Number, Hash>
where\n Number: Encode,\n Hash: Encode,
"],["impl<Balance> Encode for ProtocolMessageRequest<Balance>
where\n InitiateChannelParams<Balance>: Encode,
"],["impl Encode for ChainId"],["impl<Balance> Encode for InitiateChannelParams<Balance>
where\n FeeModel<Balance>: Encode,
"],["impl<BlockNumber, BlockHash, StateRoot> Encode for CrossDomainMessage<BlockNumber, BlockHash, StateRoot>
where\n Proof<BlockNumber, BlockHash, StateRoot>: Encode,
"],["impl Encode for MessageWeightTag"],["impl Encode for BlockMessageWithStorageKey"],["impl<Balance> Encode for Message<Balance>
where\n VersionedPayload<Balance>: Encode,
"],["impl<BlockNumber, BlockHash, StateRoot> Encode for ExtractedStateRootsFromProof<BlockNumber, BlockHash, StateRoot>
where\n BlockInfo<BlockNumber, BlockHash>: Encode,\n StateRoot: Encode,\n Option<(DomainId, BlockInfo<BlockNumber, BlockHash>, StateRoot)>: Encode,
"],["impl<Request, Response> Encode for RequestResponse<Request, Response>
where\n Request: Encode,\n Response: Encode,
"],["impl Encode for EndpointRequest"],["impl Encode for BlockMessagesWithStorageKey"],["impl<Balance> Encode for Payload<Balance>
where\n RequestResponse<ProtocolMessageRequest<Balance>, ProtocolMessageResponse>: Encode,
"],["impl<Balance> Encode for FeeModel<Balance>
where\n Balance: Encode,
"],["impl<Balance> Encode for VersionedPayload<Balance>
where\n Payload<Balance>: Encode,
"],["impl Encode for Endpoint"],["impl<BlockNumber, BlockHash, StateRoot> Encode for Proof<BlockNumber, BlockHash, StateRoot>
where\n BlockInfo<BlockNumber, BlockHash>: Encode,\n StateRoot: Encode,\n Option<(BlockInfo<BlockNumber, BlockHash>, StorageProof)>: Encode,
"]], "sp_subspace_mmr":[["impl<BlockNumber, Hash> Encode for MmrLeaf<BlockNumber, Hash>
where\n LeafDataV0<BlockNumber, Hash>: Encode,
"],["impl<MmrRootHash> Encode for MmrDigestItem<MmrRootHash>
where\n MmrRootHash: Encode + Codec,
"],["impl<BlockNumber, Hash> Encode for LeafDataV0<BlockNumber, Hash>
where\n BlockNumber: Encode,\n Hash: Encode,
"]], "subspace_archiving":[["impl Encode for SegmentItem"],["impl Encode for Segment"],["impl Encode for NewArchivedSegment"]], "subspace_core_primitives":[["impl Encode for SegmentHeader"],["impl Encode for PublicKey"],["impl Encode for PosProof"],["impl<PublicKey, RewardAddress> Encode for Solution<PublicKey, RewardAddress>
where\n PublicKey: Encode,\n RewardAddress: Encode,
"],["impl Encode for RecordCommitment"],["impl Encode for PotKey"],["impl Encode for PieceObject"],["impl Encode for PotOutput"],["impl Encode for PotCheckpoints"],["impl Encode for ArchivedHistorySegment"],["impl Encode for ArchivedBlockProgress"],["impl Encode for PieceObjectMapping"],["impl Encode for Randomness"],["impl Encode for Scalar"],["impl Encode for PieceOffset"],["impl Encode for HistorySize"],["impl<T> Encode for Blake3Checksummed<T>
where\n T: Encode,
"],["impl Encode for ChunkWitness"],["impl Encode for U256"],["impl Encode for PieceArray"],["impl Encode for RecordWitness"],["impl Encode for BlockObject"],["impl Encode for FlatPieces"],["impl Encode for PieceIndex"],["impl Encode for BlockObjectMapping"],["impl Encode for GlobalObject"],["impl Encode for SBucket"],["impl Encode for LastArchivedBlock"],["impl<T> Encode for NonEmptyVec<T>
where\n Vec<T>: Encode,
"],["impl Encode for RewardSignature"],["impl Encode for SegmentIndex"],["impl Encode for SectorId"],["impl Encode for Piece"],["impl Encode for SegmentCommitment"],["impl Encode for PotSeed"]], -"subspace_farmer":[["impl Encode for SectorPlottingDetails"],["impl Encode for FarmingError"],["impl Encode for SectorUpdate"],["impl Encode for FarmingNotification"],["impl Encode for AuditingDetails"],["impl Encode for DecodedFarmingError"],["impl Encode for ProvingResult"],["impl Encode for SectorExpirationDetails"],["impl Encode for ProvingDetails"]], +"subspace_farmer":[["impl Encode for ProvingDetails"],["impl Encode for AuditingDetails"],["impl Encode for FarmingNotification"],["impl Encode for FarmingError"],["impl Encode for ProvingResult"],["impl Encode for DecodedFarmingError"],["impl Encode for SectorPlottingDetails"],["impl Encode for SectorUpdate"],["impl Encode for SectorExpirationDetails"]], "subspace_farmer_components":[["impl Encode for SectorMetadataChecksummed"],["impl Encode for PlottedSector"],["impl Encode for SectorMetadata"]], "subspace_networking":[["impl Encode for SegmentHeaderRequest"],["impl Encode for SegmentHeaderResponse"],["impl Encode for PieceByIndexResponse"],["impl Encode for PieceByIndexRequest"]], "subspace_runtime":[["impl Encode for RuntimeFreezeReason"],["impl Encode for OriginCaller"],["impl Encode for RuntimeLockId"],["impl Encode for SessionKeys"],["impl Encode for HoldIdentifier"],["impl Encode for DisablePallets"],["impl Encode for RuntimeCall"],["impl Encode for RuntimeSlashReason"],["impl Encode for RuntimeError"],["impl Encode for CheckStorageAccess"],["impl Encode for RuntimeEvent"],["impl Encode for RuntimeHoldReason"],["impl Encode for RuntimeTask"]], diff --git a/trait.impl/parity_scale_codec/encode_like/trait.EncodeLike.js b/trait.impl/parity_scale_codec/encode_like/trait.EncodeLike.js index 353e0258dd..05e8c84ca8 100644 --- a/trait.impl/parity_scale_codec/encode_like/trait.EncodeLike.js +++ b/trait.impl/parity_scale_codec/encode_like/trait.EncodeLike.js @@ -21,14 +21,14 @@ "pallet_transporter":[["impl EncodeLike for Location"],["impl<Balance> EncodeLike for Transfer<Balance>
where\n Balance: Encode,
"],["impl<T> EncodeLike for Error<T>"],["impl<T: Config> EncodeLike for Call<T>"],["impl<T: Config> EncodeLike for Event<T>
where\n <<T as Config>::Sender as Sender<<T as Config>::AccountId>>::MessageId: Encode,
"]], "sp_block_fees":[["impl EncodeLike for InherentError"]], "sp_consensus_subspace":[["impl<Number, Hash, RewardAddress> EncodeLike for SignedVote<Number, Hash, RewardAddress>
where\n Vote<Number, Hash, RewardAddress>: Encode,
"],["impl EncodeLike for PotNextSlotInput"],["impl EncodeLike for InherentType"],["impl EncodeLike for SolutionRanges"],["impl<Number, Hash, RewardAddress> EncodeLike for Vote<Number, Hash, RewardAddress>
where\n Number: Encode,\n Hash: Encode,\n Solution<FarmerPublicKey, RewardAddress>: Encode,
"],["impl EncodeLike for InherentError"],["impl EncodeLike for WrappedSolution"],["impl<PublicKey, RewardAddress> EncodeLike for PreDigest<PublicKey, RewardAddress>
where\n Solution<PublicKey, RewardAddress>: Encode,
"],["impl EncodeLike for PreDigestPotInfo"],["impl<'a> EncodeLike for WrappedVerifySolutionParams<'a>"],["impl EncodeLike for PotParametersChange"],["impl EncodeLike for SubspaceJustification"],["impl EncodeLike for ChainConstants"],["impl EncodeLike for PotParameters"],["impl EncodeLike for WrappedPotOutput"],["impl<Offender> EncodeLike for OffenceDetails<Offender>
where\n Offender: Encode,
"]], -"sp_domains":[["impl<Number, Hash, DomainHeader: HeaderT, Balance> EncodeLike for BundleHeader<Number, Hash, DomainHeader, Balance>
where\n ProofOfElection<Hash>: Encode,\n ExecutionReceipt<Number, Hash, HeaderNumberFor<DomainHeader>, HeaderHashFor<DomainHeader>, Balance>: Encode,\n HeaderHashFor<DomainHeader>: Encode,
"],["impl<AccountId: Ord> EncodeLike for OperatorAllowList<AccountId>
where\n BTreeSet<AccountId>: Encode,
"],["impl EncodeLike for StakingHoldIdentifier"],["impl EncodeLike for DomainInstanceData"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> EncodeLike for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,
"],["impl EncodeLike for ProofOfElectionError"],["impl EncodeLike for StorageData"],["impl<Number, Hash, DomainHeader: HeaderT, Balance> EncodeLike for SealedBundleHeader<Number, Hash, DomainHeader, Balance>
where\n BundleHeader<Number, Hash, DomainHeader, Balance>: Encode,
"],["impl EncodeLike for DomainDigestItem"],["impl<Hash> EncodeLike for BundleValidity<Hash>
where\n Hash: Encode,
"],["impl EncodeLike for StorageKey"],["impl<AccountId> EncodeLike for GenesisDomain<AccountId>
where\n AccountId: Encode + Ord,\n OperatorAllowList<AccountId>: Encode,
"],["impl EncodeLike for DomainsHoldIdentifier"],["impl<Hash> EncodeLike for InboxedBundle<Hash>
where\n BundleValidity<Hash>: Encode,\n Hash: Encode,
"],["impl EncodeLike for InvalidBundleType"],["impl<Hash> EncodeLike for BundleDigest<Hash>
where\n Hash: Encode,
"],["impl EncodeLike for ReceiptValidity"],["impl EncodeLike for ExtrinsicDigest"],["impl EncodeLike for DomainId"],["impl EncodeLike for VerificationError"],["impl EncodeLike for InvalidReceipt"],["impl EncodeLike for RuntimeType"],["impl EncodeLike for Witness"],["impl<Balance> EncodeLike for BundleProducerElectionParams<Balance>
where\n Balance: Encode,
"],["impl EncodeLike for DomainBlockLimit"],["impl<CHash> EncodeLike for ProofOfElection<CHash>
where\n CHash: Encode,
"],["impl EncodeLike for RawGenesis"],["impl<Extrinsic, Number, Hash, DomainHeader: HeaderT, Balance> EncodeLike for Bundle<Extrinsic, Number, Hash, DomainHeader, Balance>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: Encode,\n Vec<Extrinsic>: Encode,
"]], +"sp_domains":[["impl<Number, Hash, DomainHeader: HeaderT, Balance> EncodeLike for BundleHeader<Number, Hash, DomainHeader, Balance>
where\n ProofOfElection<Hash>: Encode,\n ExecutionReceipt<Number, Hash, HeaderNumberFor<DomainHeader>, HeaderHashFor<DomainHeader>, Balance>: Encode,\n HeaderHashFor<DomainHeader>: Encode,
"],["impl<AccountId: Ord> EncodeLike for OperatorAllowList<AccountId>
where\n BTreeSet<AccountId>: Encode,
"],["impl EncodeLike for StakingHoldIdentifier"],["impl EncodeLike for DomainInstanceData"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> EncodeLike for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,
"],["impl EncodeLike for ProofOfElectionError"],["impl EncodeLike for StorageData"],["impl<Number, Hash, DomainHeader: HeaderT, Balance> EncodeLike for SealedBundleHeader<Number, Hash, DomainHeader, Balance>
where\n BundleHeader<Number, Hash, DomainHeader, Balance>: Encode,
"],["impl EncodeLike for DomainDigestItem"],["impl<Hash> EncodeLike for BundleValidity<Hash>
where\n Hash: Encode,
"],["impl EncodeLike for StorageKey"],["impl<AccountId> EncodeLike for GenesisDomain<AccountId>
where\n AccountId: Encode + Ord,\n OperatorAllowList<AccountId>: Encode,
"],["impl EncodeLike for DomainsHoldIdentifier"],["impl<Hash> EncodeLike for InboxedBundle<Hash>
where\n BundleValidity<Hash>: Encode,\n Hash: Encode,
"],["impl EncodeLike for InvalidBundleType"],["impl<Hash> EncodeLike for BundleDigest<Hash>
where\n Hash: Encode,
"],["impl EncodeLike for ReceiptValidity"],["impl EncodeLike for ExtrinsicDigest"],["impl EncodeLike for DomainId"],["impl EncodeLike for VerificationError"],["impl EncodeLike for InvalidReceipt"],["impl EncodeLike for RuntimeType"],["impl EncodeLike for Witness"],["impl<Balance> EncodeLike for BundleProducerElectionParams<Balance>
where\n Balance: Encode,
"],["impl EncodeLike for DomainBlockLimit"],["impl<CHash> EncodeLike for ProofOfElection<CHash>
where\n CHash: Encode,
"],["impl EncodeLike for RawGenesis"],["impl<Extrinsic, Number, Hash, DomainHeader: HeaderT, Balance> EncodeLike for Bundle<Extrinsic, Number, Hash, DomainHeader, Balance>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: Encode,\n Vec<Extrinsic>: Encode,
"]], "sp_domains_fraud_proof":[["impl EncodeLike for FraudProofVerificationInfoRequest"],["impl<ReceiptHash> EncodeLike for InvalidExtrinsicsRootProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl<Number, Hash, DomainHeader: HeaderT> EncodeLike for BundleEquivocationProof<Number, Hash, DomainHeader>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: Encode,
"],["impl EncodeLike for SetCodeExtrinsic"],["impl<Number, Hash, DomainHeader: HeaderT> EncodeLike for FraudProof<Number, Hash, DomainHeader>
where\n InvalidStateTransitionProof<HeaderHashFor<DomainHeader>>: Encode,\n InvalidTransactionProof<HeaderHashFor<DomainHeader>>: Encode,\n BundleEquivocationProof<Number, Hash, DomainHeader>: Encode,\n ImproperTransactionSortitionProof<HeaderHashFor<DomainHeader>>: Encode,\n InvalidBlockFeesProof<HeaderHashFor<DomainHeader>>: Encode,\n InvalidExtrinsicsRootProof<HeaderHashFor<DomainHeader>>: Encode,\n ValidBundleProof<HeaderHashFor<DomainHeader>>: Encode,\n InvalidDomainBlockHashProof<HeaderHashFor<DomainHeader>>: Encode,\n InvalidBundlesFraudProof<HeaderHashFor<DomainHeader>>: Encode,\n HeaderHashFor<DomainHeader>: Encode,
"],["impl EncodeLike for ApplyExtrinsicMismatch"],["impl<ReceiptHash> EncodeLike for InvalidBundlesFraudProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl EncodeLike for FinalizeBlockMismatch"],["impl<ReceiptHash> EncodeLike for InvalidStateTransitionProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl<ReceiptHash> EncodeLike for InvalidDomainBlockHashProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl EncodeLike for FraudProofVerificationInfoResponse"],["impl EncodeLike for ValidBundleDigest"],["impl EncodeLike for ExecutionPhase"],["impl<ReceiptHash> EncodeLike for ImproperTransactionSortitionProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl<ReceiptHash> EncodeLike for ValidBundleProof<ReceiptHash>
where\n ReceiptHash: Encode,
"],["impl<DomainHash> EncodeLike for InvalidTransactionProof<DomainHash>
where\n DomainHash: Encode,
"],["impl<ReceiptHash> EncodeLike for InvalidBlockFeesProof<ReceiptHash>
where\n ReceiptHash: Encode,
"]], "sp_executive":[["impl EncodeLike for InherentType"],["impl EncodeLike for InherentError"]], "sp_messenger":[["impl EncodeLike for Endpoint"],["impl<BlockNumber, BlockHash, StateRoot> EncodeLike for ExtractedStateRootsFromProof<BlockNumber, BlockHash, StateRoot>
where\n BlockInfo<BlockNumber, BlockHash>: Encode,\n StateRoot: Encode,\n Option<(DomainId, BlockInfo<BlockNumber, BlockHash>, StateRoot)>: Encode,
"],["impl<Balance> EncodeLike for FeeModel<Balance>
where\n Balance: Encode,
"],["impl EncodeLike for BlockMessageWithStorageKey"],["impl EncodeLike for ChainId"],["impl<Balance> EncodeLike for ProtocolMessageRequest<Balance>
where\n InitiateChannelParams<Balance>: Encode,
"],["impl<Balance> EncodeLike for VersionedPayload<Balance>
where\n Payload<Balance>: Encode,
"],["impl<Balance> EncodeLike for InitiateChannelParams<Balance>
where\n FeeModel<Balance>: Encode,
"],["impl<Balance> EncodeLike for Message<Balance>
where\n VersionedPayload<Balance>: Encode,
"],["impl EncodeLike for EndpointRequest"],["impl EncodeLike for BlockMessagesWithStorageKey"],["impl<BlockNumber, BlockHash, StateRoot> EncodeLike for Proof<BlockNumber, BlockHash, StateRoot>
where\n BlockInfo<BlockNumber, BlockHash>: Encode,\n StateRoot: Encode,\n Option<(BlockInfo<BlockNumber, BlockHash>, StorageProof)>: Encode,
"],["impl<Request, Response> EncodeLike for RequestResponse<Request, Response>
where\n Request: Encode,\n Response: Encode,
"],["impl EncodeLike for MessageWeightTag"],["impl<Balance> EncodeLike for Payload<Balance>
where\n RequestResponse<ProtocolMessageRequest<Balance>, ProtocolMessageResponse>: Encode,
"],["impl<BlockNumber, BlockHash, StateRoot> EncodeLike for CrossDomainMessage<BlockNumber, BlockHash, StateRoot>
where\n Proof<BlockNumber, BlockHash, StateRoot>: Encode,
"],["impl<Number, Hash> EncodeLike for BlockInfo<Number, Hash>
where\n Number: Encode,\n Hash: Encode,
"]], "sp_subspace_mmr":[["impl<MmrRootHash> EncodeLike for MmrDigestItem<MmrRootHash>
where\n MmrRootHash: Encode + Codec,
"],["impl<BlockNumber, Hash> EncodeLike for MmrLeaf<BlockNumber, Hash>
where\n LeafDataV0<BlockNumber, Hash>: Encode,
"],["impl<BlockNumber, Hash> EncodeLike for LeafDataV0<BlockNumber, Hash>
where\n BlockNumber: Encode,\n Hash: Encode,
"]], "subspace_archiving":[["impl EncodeLike for NewArchivedSegment"],["impl EncodeLike for SegmentItem"]], "subspace_core_primitives":[["impl EncodeLike for PublicKey"],["impl EncodeLike for RecordCommitment"],["impl EncodeLike for PieceObject"],["impl EncodeLike for U256"],["impl EncodeLike for PieceIndex"],["impl EncodeLike for PotOutput"],["impl EncodeLike for RecordWitness"],["impl EncodeLike for PieceOffset"],["impl EncodeLike for SegmentHeader"],["impl EncodeLike for BlockObjectMapping"],["impl EncodeLike for PotSeed"],["impl EncodeLike for BlockObject"],["impl EncodeLike for RewardSignature"],["impl<T> EncodeLike for Blake3Checksummed<T>
where\n T: EncodeLike,
"],["impl EncodeLike for HistorySize"],["impl EncodeLike for PieceArray"],["impl EncodeLike for ChunkWitness"],["impl EncodeLike for PotCheckpoints"],["impl EncodeLike for Piece"],["impl EncodeLike for LastArchivedBlock"],["impl EncodeLike for FlatPieces"],["impl EncodeLike for Randomness"],["impl<T> EncodeLike for NonEmptyVec<T>
where\n Vec<T>: Encode,
"],["impl EncodeLike for SBucket"],["impl EncodeLike for Scalar"],["impl EncodeLike for GlobalObject"],["impl EncodeLike for ArchivedBlockProgress"],["impl EncodeLike for PosProof"],["impl EncodeLike for SegmentCommitment"],["impl<PublicKey, RewardAddress> EncodeLike for Solution<PublicKey, RewardAddress>
where\n PublicKey: Encode,\n RewardAddress: Encode,
"],["impl EncodeLike for PotKey"],["impl EncodeLike for ArchivedHistorySegment"],["impl EncodeLike for PieceObjectMapping"],["impl EncodeLike for SectorId"],["impl EncodeLike for SegmentIndex"]], -"subspace_farmer":[["impl EncodeLike for ProvingResult"],["impl EncodeLike for FarmingNotification"],["impl EncodeLike for SectorPlottingDetails"],["impl EncodeLike for SectorExpirationDetails"],["impl EncodeLike for AuditingDetails"],["impl EncodeLike for SectorUpdate"],["impl EncodeLike for DecodedFarmingError"],["impl EncodeLike for ProvingDetails"]], +"subspace_farmer":[["impl EncodeLike for SectorPlottingDetails"],["impl EncodeLike for FarmingNotification"],["impl EncodeLike for SectorUpdate"],["impl EncodeLike for ProvingResult"],["impl EncodeLike for DecodedFarmingError"],["impl EncodeLike for SectorExpirationDetails"],["impl EncodeLike for AuditingDetails"],["impl EncodeLike for ProvingDetails"]], "subspace_farmer_components":[["impl EncodeLike for PlottedSector"],["impl EncodeLike for SectorMetadataChecksummed"],["impl EncodeLike for SectorMetadata"]], "subspace_networking":[["impl EncodeLike for PieceByIndexRequest"],["impl EncodeLike for SegmentHeaderResponse"],["impl EncodeLike for SegmentHeaderRequest"],["impl EncodeLike for PieceByIndexResponse"]], "subspace_runtime":[["impl EncodeLike for RuntimeHoldReason"],["impl EncodeLike for OriginCaller"],["impl EncodeLike for RuntimeError"],["impl EncodeLike for RuntimeFreezeReason"],["impl EncodeLike for SessionKeys"],["impl EncodeLike for CheckStorageAccess"],["impl EncodeLike for DisablePallets"],["impl EncodeLike for RuntimeTask"],["impl EncodeLike for RuntimeCall"],["impl EncodeLike for RuntimeLockId"],["impl EncodeLike for RuntimeEvent"],["impl EncodeLike for HoldIdentifier"],["impl EncodeLike for RuntimeSlashReason"]], diff --git a/trait.impl/scale_info/trait.TypeInfo.js b/trait.impl/scale_info/trait.TypeInfo.js index 239092ec64..6c14125535 100644 --- a/trait.impl/scale_info/trait.TypeInfo.js +++ b/trait.impl/scale_info/trait.TypeInfo.js @@ -19,7 +19,7 @@ "pallet_transaction_fees":[["impl<T> TypeInfo for Event<T>
where\n T::AccountId: 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: Config + 'static,
"]], "pallet_transporter":[["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl TypeInfo for Location"],["impl<Balance> TypeInfo for Transfer<Balance>
where\n Balance: TypeInfo + 'static,
"],["impl<T> TypeInfo for Event<T>
where\n <<T as Config>::Sender as Sender<<T as Config>::AccountId>>::MessageId: 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 as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n T: Config + 'static,
"]], "sp_consensus_subspace":[["impl TypeInfo for ChainConstants"],["impl<Number, Hash, RewardAddress> TypeInfo for SignedVote<Number, Hash, RewardAddress>
where\n Vote<Number, Hash, RewardAddress>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n RewardAddress: TypeInfo + 'static,
"],["impl TypeInfo for PotParameters"],["impl TypeInfo for PotParametersChange"],["impl TypeInfo for SolutionRanges"],["impl<Number, Hash, RewardAddress> TypeInfo for Vote<Number, Hash, RewardAddress>
where\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n Solution<FarmerPublicKey, RewardAddress>: TypeInfo + 'static,\n RewardAddress: TypeInfo + 'static,
"],["impl<Offender> TypeInfo for OffenceDetails<Offender>
where\n Offender: TypeInfo + 'static,
"],["impl TypeInfo for PotNextSlotInput"],["impl TypeInfo for SubspaceJustification"]], -"sp_domains":[["impl TypeInfo for DomainsHoldIdentifier"],["impl TypeInfo for RawGenesis"],["impl TypeInfo for ExtrinsicDigest"],["impl TypeInfo for StakingHoldIdentifier"],["impl TypeInfo for ReceiptValidity"],["impl<Number, Hash, DomainHeader, Balance> TypeInfo for SealedBundleHeader<Number, Hash, DomainHeader, Balance>
where\n BundleHeader<Number, Hash, DomainHeader, Balance>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainHeader: HeaderT + TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl TypeInfo for DomainId"],["impl<AccountId> TypeInfo for OperatorAllowList<AccountId>
where\n BTreeSet<AccountId>: TypeInfo + 'static,\n AccountId: Ord + TypeInfo + 'static,
"],["impl TypeInfo for InvalidBundleType"],["impl TypeInfo for InvalidReceipt"],["impl TypeInfo for DomainBlockLimit"],["impl<Hash> TypeInfo for InboxedBundle<Hash>
where\n BundleValidity<Hash>: TypeInfo + 'static,\n Hash: TypeInfo + 'static,
"],["impl TypeInfo for RuntimeType"],["impl TypeInfo for ProofOfElectionError"],["impl TypeInfo for StorageData"],["impl TypeInfo for DomainInstanceData"],["impl<Extrinsic, Number, Hash, DomainHeader, Balance> TypeInfo for Bundle<Extrinsic, Number, Hash, DomainHeader, Balance>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: TypeInfo + 'static,\n Vec<Extrinsic>: TypeInfo + 'static,\n Extrinsic: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainHeader: HeaderT + TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl<CHash> TypeInfo for ProofOfElection<CHash>
where\n CHash: TypeInfo + 'static,
"],["impl<Hash> TypeInfo for BundleValidity<Hash>
where\n Hash: TypeInfo + 'static,
"],["impl TypeInfo for StorageKey"],["impl<Hash> TypeInfo for BundleDigest<Hash>
where\n Hash: TypeInfo + 'static,
"],["impl<Balance> TypeInfo for BundleProducerElectionParams<Balance>
where\n Balance: TypeInfo + 'static,
"],["impl<AccountId> TypeInfo for GenesisDomain<AccountId>
where\n AccountId: TypeInfo + 'static + Ord,\n OperatorAllowList<AccountId>: TypeInfo + 'static,
"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: TypeInfo + 'static,\n DomainHash: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n Vec<InboxedBundle<DomainHash>>: TypeInfo + 'static,\n Vec<DomainHash>: TypeInfo + 'static,\n BlockFees<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl TypeInfo for DomainDigestItem"],["impl TypeInfo for VerificationError"],["impl<Number, Hash, DomainHeader, Balance> TypeInfo for BundleHeader<Number, Hash, DomainHeader, Balance>
where\n ProofOfElection<Hash>: TypeInfo + 'static,\n ExecutionReceipt<Number, Hash, HeaderNumberFor<DomainHeader>, HeaderHashFor<DomainHeader>, Balance>: TypeInfo + 'static,\n HeaderHashFor<DomainHeader>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainHeader: HeaderT + TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl TypeInfo for Witness"]], +"sp_domains":[["impl TypeInfo for DomainsHoldIdentifier"],["impl TypeInfo for RawGenesis"],["impl TypeInfo for ExtrinsicDigest"],["impl TypeInfo for StakingHoldIdentifier"],["impl TypeInfo for ReceiptValidity"],["impl<Number, Hash, DomainHeader, Balance> TypeInfo for SealedBundleHeader<Number, Hash, DomainHeader, Balance>
where\n BundleHeader<Number, Hash, DomainHeader, Balance>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainHeader: HeaderT + TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl TypeInfo for DomainId"],["impl<AccountId> TypeInfo for OperatorAllowList<AccountId>
where\n BTreeSet<AccountId>: TypeInfo + 'static,\n AccountId: Ord + TypeInfo + 'static,
"],["impl TypeInfo for InvalidBundleType"],["impl TypeInfo for InvalidReceipt"],["impl TypeInfo for DomainBlockLimit"],["impl<Hash> TypeInfo for InboxedBundle<Hash>
where\n BundleValidity<Hash>: TypeInfo + 'static,\n Hash: TypeInfo + 'static,
"],["impl TypeInfo for RuntimeType"],["impl TypeInfo for ProofOfElectionError"],["impl TypeInfo for StorageData"],["impl TypeInfo for DomainInstanceData"],["impl<Extrinsic, Number, Hash, DomainHeader, Balance> TypeInfo for Bundle<Extrinsic, Number, Hash, DomainHeader, Balance>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: TypeInfo + 'static,\n Vec<Extrinsic>: TypeInfo + 'static,\n Extrinsic: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainHeader: HeaderT + TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl<CHash> TypeInfo for ProofOfElection<CHash>
where\n CHash: TypeInfo + 'static,
"],["impl<Hash> TypeInfo for BundleValidity<Hash>
where\n Hash: TypeInfo + 'static,
"],["impl TypeInfo for StorageKey"],["impl<Hash> TypeInfo for BundleDigest<Hash>
where\n Hash: TypeInfo + 'static,
"],["impl<Balance> TypeInfo for BundleProducerElectionParams<Balance>
where\n Balance: TypeInfo + 'static,
"],["impl<AccountId> TypeInfo for GenesisDomain<AccountId>
where\n AccountId: TypeInfo + 'static + Ord,\n OperatorAllowList<AccountId>: TypeInfo + 'static,
"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: TypeInfo + 'static,\n DomainHash: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n Vec<InboxedBundle<DomainHash>>: TypeInfo + 'static,\n Vec<DomainHash>: TypeInfo + 'static,\n BlockFees<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl TypeInfo for DomainDigestItem"],["impl TypeInfo for VerificationError"],["impl<Number, Hash, DomainHeader, Balance> TypeInfo for BundleHeader<Number, Hash, DomainHeader, Balance>
where\n ProofOfElection<Hash>: TypeInfo + 'static,\n ExecutionReceipt<Number, Hash, HeaderNumberFor<DomainHeader>, HeaderHashFor<DomainHeader>, Balance>: TypeInfo + 'static,\n HeaderHashFor<DomainHeader>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainHeader: HeaderT + TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl TypeInfo for Witness"]], "sp_domains_fraud_proof":[["impl TypeInfo for ExecutionPhase"],["impl TypeInfo for ApplyExtrinsicMismatch"],["impl<Number, Hash, DomainHeader> TypeInfo for FraudProof<Number, Hash, DomainHeader>
where\n InvalidStateTransitionProof<HeaderHashFor<DomainHeader>>: TypeInfo + 'static,\n InvalidTransactionProof<HeaderHashFor<DomainHeader>>: TypeInfo + 'static,\n BundleEquivocationProof<Number, Hash, DomainHeader>: TypeInfo + 'static,\n ImproperTransactionSortitionProof<HeaderHashFor<DomainHeader>>: TypeInfo + 'static,\n InvalidBlockFeesProof<HeaderHashFor<DomainHeader>>: TypeInfo + 'static,\n InvalidExtrinsicsRootProof<HeaderHashFor<DomainHeader>>: TypeInfo + 'static,\n ValidBundleProof<HeaderHashFor<DomainHeader>>: TypeInfo + 'static,\n InvalidDomainBlockHashProof<HeaderHashFor<DomainHeader>>: TypeInfo + 'static,\n InvalidBundlesFraudProof<HeaderHashFor<DomainHeader>>: TypeInfo + 'static,\n HeaderHashFor<DomainHeader>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainHeader: HeaderT + TypeInfo + 'static,
"],["impl<ReceiptHash> TypeInfo for InvalidBlockFeesProof<ReceiptHash>
where\n ReceiptHash: TypeInfo + 'static,
"],["impl<ReceiptHash> TypeInfo for InvalidBundlesFraudProof<ReceiptHash>
where\n ReceiptHash: TypeInfo + 'static,
"],["impl TypeInfo for ValidBundleDigest"],["impl<DomainHash> TypeInfo for InvalidTransactionProof<DomainHash>
where\n DomainHash: TypeInfo + 'static,
"],["impl TypeInfo for SetCodeExtrinsic"],["impl<ReceiptHash> TypeInfo for ValidBundleProof<ReceiptHash>
where\n ReceiptHash: TypeInfo + 'static,
"],["impl<Number, Hash, DomainHeader> TypeInfo for BundleEquivocationProof<Number, Hash, DomainHeader>
where\n SealedBundleHeader<Number, Hash, DomainHeader, Balance>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainHeader: HeaderT + TypeInfo + 'static,
"],["impl<ReceiptHash> TypeInfo for InvalidExtrinsicsRootProof<ReceiptHash>
where\n ReceiptHash: TypeInfo + 'static,
"],["impl TypeInfo for FraudProofVerificationInfoResponse"],["impl<ReceiptHash> TypeInfo for ImproperTransactionSortitionProof<ReceiptHash>
where\n ReceiptHash: TypeInfo + 'static,
"],["impl<ReceiptHash> TypeInfo for InvalidDomainBlockHashProof<ReceiptHash>
where\n ReceiptHash: TypeInfo + 'static,
"],["impl TypeInfo for FraudProofVerificationInfoRequest"],["impl<ReceiptHash> TypeInfo for InvalidStateTransitionProof<ReceiptHash>
where\n ReceiptHash: TypeInfo + 'static,
"],["impl TypeInfo for FinalizeBlockMismatch"]], "sp_messenger":[["impl<Balance> TypeInfo for ProtocolMessageRequest<Balance>
where\n InitiateChannelParams<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl<BlockNumber, BlockHash, StateRoot> TypeInfo for Proof<BlockNumber, BlockHash, StateRoot>
where\n BlockInfo<BlockNumber, BlockHash>: TypeInfo + 'static,\n StateRoot: TypeInfo + 'static,\n Option<(BlockInfo<BlockNumber, BlockHash>, StorageProof)>: TypeInfo + 'static,\n BlockNumber: TypeInfo + 'static,\n BlockHash: TypeInfo + 'static,
"],["impl TypeInfo for Endpoint"],["impl<Request, Response> TypeInfo for RequestResponse<Request, Response>
where\n Request: TypeInfo + 'static,\n Response: TypeInfo + 'static,
"],["impl<Balance> TypeInfo for FeeModel<Balance>
where\n Balance: TypeInfo + 'static,
"],["impl<Balance> TypeInfo for Message<Balance>
where\n VersionedPayload<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl<Balance> TypeInfo for Payload<Balance>
where\n RequestResponse<ProtocolMessageRequest<Balance>, ProtocolMessageResponse>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl<Balance> TypeInfo for InitiateChannelParams<Balance>
where\n FeeModel<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl TypeInfo for ChainId"],["impl<Balance> TypeInfo for VersionedPayload<Balance>
where\n Payload<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl<Number, Hash> TypeInfo for BlockInfo<Number, Hash>
where\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,
"],["impl<BlockNumber, BlockHash, StateRoot> TypeInfo for CrossDomainMessage<BlockNumber, BlockHash, StateRoot>
where\n Proof<BlockNumber, BlockHash, StateRoot>: TypeInfo + 'static,\n BlockNumber: TypeInfo + 'static,\n BlockHash: TypeInfo + 'static,\n StateRoot: TypeInfo + 'static,
"],["impl TypeInfo for BlockMessageWithStorageKey"],["impl<BlockNumber, BlockHash, StateRoot> TypeInfo for ExtractedStateRootsFromProof<BlockNumber, BlockHash, StateRoot>
where\n BlockInfo<BlockNumber, BlockHash>: TypeInfo + 'static,\n StateRoot: TypeInfo + 'static,\n Option<(DomainId, BlockInfo<BlockNumber, BlockHash>, StateRoot)>: TypeInfo + 'static,\n BlockNumber: TypeInfo + 'static,\n BlockHash: TypeInfo + 'static,
"],["impl TypeInfo for MessageWeightTag"],["impl TypeInfo for EndpointRequest"],["impl TypeInfo for BlockMessagesWithStorageKey"]], "sp_subspace_mmr":[["impl<BlockNumber, Hash> TypeInfo for LeafDataV0<BlockNumber, Hash>
where\n BlockNumber: TypeInfo + 'static,\n Hash: TypeInfo + 'static,
"],["impl<BlockNumber, Hash> TypeInfo for MmrLeaf<BlockNumber, Hash>
where\n LeafDataV0<BlockNumber, Hash>: TypeInfo + 'static,\n BlockNumber: TypeInfo + 'static,\n Hash: TypeInfo + 'static,
"],["impl<MmrRootHash> TypeInfo for MmrDigestItem<MmrRootHash>
where\n MmrRootHash: TypeInfo + 'static + Codec,
"]], diff --git a/trait.impl/serde/de/trait.Deserialize.js b/trait.impl/serde/de/trait.Deserialize.js index 6c2ec01d62..e1bccd4a90 100644 --- a/trait.impl/serde/de/trait.Deserialize.js +++ b/trait.impl/serde/de/trait.Deserialize.js @@ -11,7 +11,7 @@ "sp_messenger":[["impl<'de> Deserialize<'de> for ChainId"]], "subspace_archiving":[["impl<'de> Deserialize<'de> for NewArchivedSegment"]], "subspace_core_primitives":[["impl<'de> Deserialize<'de> for GlobalObject"],["impl<'de> Deserialize<'de> for SectorId"],["impl<'de> Deserialize<'de> for Piece"],["impl<'de> Deserialize<'de> for Randomness"],["impl<'de> Deserialize<'de> for RecordWitness"],["impl<'de> Deserialize<'de> for FlatPieces"],["impl<'de> Deserialize<'de> for SegmentHeader"],["impl<'de> Deserialize<'de> for Scalar"],["impl<'de> Deserialize<'de> for PotKey"],["impl<'de> Deserialize<'de> for PieceIndex"],["impl<'de> Deserialize<'de> for PieceOffset"],["impl<'de> Deserialize<'de> for PieceArray"],["impl<'de> Deserialize<'de> for ChunkWitness"],["impl<'de> Deserialize<'de> for ArchivedBlockProgress"],["impl<'de> Deserialize<'de> for PieceObject"],["impl<'de> Deserialize<'de> for PieceObjectMapping"],["impl<'de> Deserialize<'de> for SegmentIndex"],["impl<'de> Deserialize<'de> for BlockObjectMapping"],["impl<'de> Deserialize<'de> for PublicKey"],["impl<'de> Deserialize<'de> for PosProof"],["impl<'de> Deserialize<'de> for SBucket"],["impl<'de> Deserialize<'de> for PotSeed"],["impl<'de> Deserialize<'de> for RewardSignature"],["impl<'de> Deserialize<'de> for ArchivedHistorySegment"],["impl<'de> Deserialize<'de> for HistorySize"],["impl<'de> Deserialize<'de> for SegmentCommitment"],["impl<'de> Deserialize<'de> for PotOutput"],["impl<'de> Deserialize<'de> for BlockObject"],["impl<'de, PublicKey, RewardAddress> Deserialize<'de> for Solution<PublicKey, RewardAddress>
where\n PublicKey: Deserialize<'de>,\n RewardAddress: Deserialize<'de>,
"],["impl<'de> Deserialize<'de> for RecordCommitment"],["impl<'de> Deserialize<'de> for LastArchivedBlock"]], -"subspace_farmer":[["impl<'de> Deserialize<'de> for SingleDiskFarmId"],["impl<'de> Deserialize<'de> for SingleDiskFarmInfo"]], +"subspace_farmer":[["impl<'de> Deserialize<'de> for SingleDiskFarmInfo"],["impl<'de> Deserialize<'de> for SingleDiskFarmId"]], "subspace_farmer_components":[["impl<'de> Deserialize<'de> for FarmerProtocolInfo"]], "subspace_rpc_primitives":[["impl<'de> Deserialize<'de> for NodeSyncStatus"],["impl<'de> Deserialize<'de> for FarmerAppInfo"],["impl<'de> Deserialize<'de> for RewardSigningInfo"],["impl<'de> Deserialize<'de> for RewardSignatureResponse"],["impl<'de> Deserialize<'de> for SolutionResponse"],["impl<'de> Deserialize<'de> for SlotInfo"]], "subspace_runtime":[["impl<'de> Deserialize<'de> for RuntimeGenesisConfig"],["impl<'de> Deserialize<'de> for SessionKeys"]], diff --git a/type.impl/sp_domains/struct.ExecutionReceipt.js b/type.impl/sp_domains/struct.ExecutionReceipt.js index 3c8960f22c..44655dd33c 100644 --- a/type.impl/sp_domains/struct.ExecutionReceipt.js +++ b/type.impl/sp_domains/struct.ExecutionReceipt.js @@ -1,5 +1,5 @@ (function() {var type_impls = { "domain_client_operator":[["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

pub fn bundles_extrinsics_roots(&self) -> Vec<&DomainHash>

pub fn valid_bundle_digest_at(&self, index: usize) -> Option<DomainHash>
where\n DomainHash: Copy,

pub fn valid_bundle_digests(&self) -> Vec<DomainHash>
where\n DomainHash: Copy,

pub fn valid_bundle_indexes(&self) -> Vec<u32>

",0,"domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n Number: Encode + Zero,\n Hash: Encode + Default,\n DomainNumber: Encode + Zero,\n DomainHash: Clone + Encode + Default,\n Balance: Encode + Zero + Default,

pub fn hash<DomainHashing>(&self) -> DomainHash
where\n DomainHashing: Hash<Output = DomainHash>,

Returns the hash of this execution receipt.

\n

pub fn genesis(\n genesis_state_root: DomainHash,\n genesis_extrinsic_root: DomainHash,\n genesis_domain_block_hash: DomainHash\n) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

pub fn dummy<DomainHashing>(\n consensus_block_number: Number,\n consensus_block_hash: Hash,\n domain_block_number: DomainNumber,\n parent_domain_block_receipt_hash: DomainHash\n) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainHashing: Hash<Output = DomainHash>,

",0,"domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralPartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

","StructuralPartialEq","domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> PartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n Number: PartialEq,\n Hash: PartialEq,\n DomainNumber: PartialEq,\n DomainHash: PartialEq,\n Balance: PartialEq,

§

fn eq(\n &self,\n other: &ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>\n) -> 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","domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

","StructuralEq","domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Debug for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n Number: Debug,\n Hash: Debug,\n DomainNumber: Debug,\n DomainHash: Debug,\n Balance: Debug,

§

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

Formats the value using the given formatter. Read more
","Debug","domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Eq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n Number: Eq,\n Hash: Eq,\n DomainNumber: Eq,\n DomainHash: Eq,\n Balance: Eq,

","Eq","domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Clone for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n Number: Clone,\n Hash: Clone,\n DomainNumber: Clone,\n DomainHash: Clone,\n Balance: Clone,

§

fn clone(\n &self\n) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

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","domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: TypeInfo + 'static,\n DomainHash: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n Vec<InboxedBundle<DomainHash>>: TypeInfo + 'static,\n Vec<DomainHash>: TypeInfo + 'static,\n BlockFees<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,

§

type Identity = ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

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

fn type_info() -> Type

Returns the static type identifier for Self.
","TypeInfo","domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> EncodeLike for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,

","EncodeLike","domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Decode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Decode,\n DomainHash: Decode,\n Number: Decode,\n Hash: Decode,\n Vec<InboxedBundle<DomainHash>>: Decode,\n Vec<DomainHash>: Decode,\n BlockFees<Balance>: Decode,

§

fn decode<__CodecInputEdqy>(\n __codec_input_edqy: &mut __CodecInputEdqy\n) -> Result<ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>, Error>
where\n __CodecInputEdqy: Input,

Attempt to deserialise the value from input.
§

fn decode_into<I>(\n input: &mut I,\n dst: &mut MaybeUninit<Self>\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","domain_client_operator::ExecutionReceiptFor"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Encode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,

§

fn size_hint(&self) -> usize

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

fn encode_to<__CodecOutputEdqy>(\n &self,\n __codec_dest_edqy: &mut __CodecOutputEdqy\n)
where\n __CodecOutputEdqy: 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","domain_client_operator::ExecutionReceiptFor"]], "pallet_domains":[["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

pub fn bundles_extrinsics_roots(&self) -> Vec<&DomainHash>

pub fn valid_bundle_digest_at(&self, index: usize) -> Option<DomainHash>
where\n DomainHash: Copy,

pub fn valid_bundle_digests(&self) -> Vec<DomainHash>
where\n DomainHash: Copy,

pub fn valid_bundle_indexes(&self) -> Vec<u32>

",0,"pallet_domains::ExecutionReceiptOf"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n Number: Encode + Zero,\n Hash: Encode + Default,\n DomainNumber: Encode + Zero,\n DomainHash: Clone + Encode + Default,\n Balance: Encode + Zero + Default,

pub fn hash<DomainHashing>(&self) -> DomainHash
where\n DomainHashing: Hash<Output = DomainHash>,

Returns the hash of this execution receipt.

\n

pub fn genesis(\n genesis_state_root: DomainHash,\n genesis_extrinsic_root: DomainHash,\n genesis_domain_block_hash: DomainHash\n) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

pub fn dummy<DomainHashing>(\n consensus_block_number: Number,\n consensus_block_hash: Hash,\n domain_block_number: DomainNumber,\n parent_domain_block_receipt_hash: DomainHash\n) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainHashing: Hash<Output = DomainHash>,

",0,"pallet_domains::ExecutionReceiptOf"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralPartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

","StructuralPartialEq","pallet_domains::ExecutionReceiptOf"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> PartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n Number: PartialEq,\n Hash: PartialEq,\n DomainNumber: PartialEq,\n DomainHash: PartialEq,\n Balance: PartialEq,

§

fn eq(\n &self,\n other: &ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>\n) -> 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::ExecutionReceiptOf"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

","StructuralEq","pallet_domains::ExecutionReceiptOf"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Debug for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n Number: Debug,\n Hash: Debug,\n DomainNumber: Debug,\n DomainHash: Debug,\n Balance: Debug,

§

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

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

impl<Number, Hash, DomainNumber, DomainHash, Balance> Eq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n Number: Eq,\n Hash: Eq,\n DomainNumber: Eq,\n DomainHash: Eq,\n Balance: Eq,

","Eq","pallet_domains::ExecutionReceiptOf"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Clone for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n Number: Clone,\n Hash: Clone,\n DomainNumber: Clone,\n DomainHash: Clone,\n Balance: Clone,

§

fn clone(\n &self\n) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

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::ExecutionReceiptOf"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: TypeInfo + 'static,\n DomainHash: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n Vec<InboxedBundle<DomainHash>>: TypeInfo + 'static,\n Vec<DomainHash>: TypeInfo + 'static,\n BlockFees<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,

§

type Identity = ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

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

fn type_info() -> Type

Returns the static type identifier for Self.
","TypeInfo","pallet_domains::ExecutionReceiptOf"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> EncodeLike for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,

","EncodeLike","pallet_domains::ExecutionReceiptOf"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Decode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Decode,\n DomainHash: Decode,\n Number: Decode,\n Hash: Decode,\n Vec<InboxedBundle<DomainHash>>: Decode,\n Vec<DomainHash>: Decode,\n BlockFees<Balance>: Decode,

§

fn decode<__CodecInputEdqy>(\n __codec_input_edqy: &mut __CodecInputEdqy\n) -> Result<ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>, Error>
where\n __CodecInputEdqy: Input,

Attempt to deserialise the value from input.
§

fn decode_into<I>(\n input: &mut I,\n dst: &mut MaybeUninit<Self>\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","pallet_domains::ExecutionReceiptOf"],["
§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Encode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,

§

fn size_hint(&self) -> usize

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

fn encode_to<__CodecOutputEdqy>(\n &self,\n __codec_dest_edqy: &mut __CodecOutputEdqy\n)
where\n __CodecOutputEdqy: 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","pallet_domains::ExecutionReceiptOf"]], -"sp_domains":[["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source

pub fn bundles_extrinsics_roots(&self) -> Vec<&DomainHash>

source

pub fn valid_bundle_digest_at(&self, index: usize) -> Option<DomainHash>
where\n DomainHash: Copy,

source

pub fn valid_bundle_digests(&self) -> Vec<DomainHash>
where\n DomainHash: Copy,

source

pub fn valid_bundle_indexes(&self) -> Vec<u32>

",0,"sp_domains::ExecutionReceiptFor"],["
source§

impl<Number: Encode + Zero, Hash: Encode + Default, DomainNumber: Encode + Zero, DomainHash: Clone + Encode + Default, Balance: Encode + Zero + Default> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source

pub fn hash<DomainHashing: HashT<Output = DomainHash>>(&self) -> DomainHash

Returns the hash of this execution receipt.

\n
source

pub fn genesis(\n genesis_state_root: DomainHash,\n genesis_extrinsic_root: DomainHash,\n genesis_domain_block_hash: DomainHash\n) -> Self

source

pub fn dummy<DomainHashing>(\n consensus_block_number: Number,\n consensus_block_hash: Hash,\n domain_block_number: DomainNumber,\n parent_domain_block_receipt_hash: DomainHash\n) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainHashing: HashT<Output = DomainHash>,

",0,"sp_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

","StructuralEq","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> EncodeLike for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,

","EncodeLike","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number: Debug, Hash: Debug, DomainNumber: Debug, DomainHash: Debug, Balance: Debug> Debug for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source§

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

Formats the value using the given formatter. Read more
","Debug","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralPartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

","StructuralPartialEq","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number: Eq, Hash: Eq, DomainNumber: Eq, DomainHash: Eq, Balance: Eq> Eq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

","Eq","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Encode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,

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>(\n &self,\n __codec_dest_edqy: &mut __CodecOutputEdqy\n)

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_domains::ExecutionReceiptFor"],["
source§

impl<Number: PartialEq, Hash: PartialEq, DomainNumber: PartialEq, DomainHash: PartialEq, Balance: PartialEq> PartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source§

fn eq(\n &self,\n other: &ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>\n) -> 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","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Decode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Decode,\n DomainHash: Decode,\n Number: Decode,\n Hash: Decode,\n Vec<InboxedBundle<DomainHash>>: Decode,\n Vec<DomainHash>: Decode,\n BlockFees<Balance>: Decode,

source§

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

Attempt to deserialise the value from input.
§

fn decode_into<I>(\n input: &mut I,\n dst: &mut MaybeUninit<Self>\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_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: TypeInfo + 'static,\n DomainHash: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n Vec<InboxedBundle<DomainHash>>: TypeInfo + 'static,\n Vec<DomainHash>: TypeInfo + 'static,\n BlockFees<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,

§

type Identity = ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

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

fn type_info() -> Type

Returns the static type identifier for Self.
","TypeInfo","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number: Clone, Hash: Clone, DomainNumber: Clone, DomainHash: Clone, Balance: Clone> Clone for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source§

fn clone(\n &self\n) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

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","sp_domains::ExecutionReceiptFor"]] +"sp_domains":[["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source

pub fn bundles_extrinsics_roots(&self) -> Vec<&DomainHash>

source

pub fn valid_bundle_digest_at(&self, index: usize) -> Option<DomainHash>
where\n DomainHash: Copy,

source

pub fn valid_bundle_digests(&self) -> Vec<DomainHash>
where\n DomainHash: Copy,

source

pub fn valid_bundle_indexes(&self) -> Vec<u32>

",0,"sp_domains::ExecutionReceiptFor"],["
source§

impl<Number: Encode + Zero, Hash: Encode + Default, DomainNumber: Encode + Zero, DomainHash: Clone + Encode + Default, Balance: Encode + Zero + Default> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source

pub fn hash<DomainHashing: HashT<Output = DomainHash>>(&self) -> DomainHash

Returns the hash of this execution receipt.

\n
source

pub fn genesis(\n genesis_state_root: DomainHash,\n genesis_extrinsic_root: DomainHash,\n genesis_domain_block_hash: DomainHash\n) -> Self

source

pub fn dummy<DomainHashing>(\n consensus_block_number: Number,\n consensus_block_hash: Hash,\n domain_block_number: DomainNumber,\n parent_domain_block_receipt_hash: DomainHash\n) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainHashing: HashT<Output = DomainHash>,

",0,"sp_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

","StructuralEq","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> EncodeLike for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,

","EncodeLike","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number: Debug, Hash: Debug, DomainNumber: Debug, DomainHash: Debug, Balance: Debug> Debug for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source§

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

Formats the value using the given formatter. Read more
","Debug","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> StructuralPartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

","StructuralPartialEq","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number: Eq, Hash: Eq, DomainNumber: Eq, DomainHash: Eq, Balance: Eq> Eq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

","Eq","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Encode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Encode,\n DomainHash: Encode,\n Number: Encode,\n Hash: Encode,\n Vec<InboxedBundle<DomainHash>>: Encode,\n Vec<DomainHash>: Encode,\n BlockFees<Balance>: Encode,

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>(\n &self,\n __codec_dest_edqy: &mut __CodecOutputEdqy\n)

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_domains::ExecutionReceiptFor"],["
source§

impl<Number: PartialEq, Hash: PartialEq, DomainNumber: PartialEq, DomainHash: PartialEq, Balance: PartialEq> PartialEq for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source§

fn eq(\n &self,\n other: &ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>\n) -> 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","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> Decode for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: Decode,\n DomainHash: Decode,\n Number: Decode,\n Hash: Decode,\n Vec<InboxedBundle<DomainHash>>: Decode,\n Vec<DomainHash>: Decode,\n BlockFees<Balance>: Decode,

source§

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

Attempt to deserialise the value from input.
§

fn decode_into<I>(\n input: &mut I,\n dst: &mut MaybeUninit<Self>\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_domains::ExecutionReceiptFor"],["
source§

impl<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>
where\n DomainNumber: TypeInfo + 'static,\n DomainHash: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n Vec<InboxedBundle<DomainHash>>: TypeInfo + 'static,\n Vec<DomainHash>: TypeInfo + 'static,\n BlockFees<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,

§

type Identity = ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

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

fn type_info() -> Type

Returns the static type identifier for Self.
","TypeInfo","sp_domains::ExecutionReceiptFor"],["
source§

impl<Number: Clone, Hash: Clone, DomainNumber: Clone, DomainHash: Clone, Balance: Clone> Clone for ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

source§

fn clone(\n &self\n) -> ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>

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","sp_domains::ExecutionReceiptFor"]] };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})() \ No newline at end of file