diff --git a/domain_client_message_relayer/enum.Error.html b/domain_client_message_relayer/enum.Error.html index dd42a63f16..c4e78a0c6b 100644 --- a/domain_client_message_relayer/enum.Error.html +++ b/domain_client_message_relayer/enum.Error.html @@ -11,7 +11,7 @@ ApiError(ApiError), DomainNonConfirmedOnConsensusChain, DomainStateRootInvalid, - UnableToSubmitCrossDomainMessage(TrySendError<Message>), + UnableToSubmitCrossDomainMessage(TrySendError<Message>), InvalidChainId, }
Expand description

Relayer error types.

Variants§

§

ConstructStorageProof

Emits when storage proof construction fails.

@@ -25,7 +25,7 @@
§

ApiError(ApiError)

Api related error.

§

DomainNonConfirmedOnConsensusChain

Emits when the core domain block is not yet confirmed on the system domain.

§

DomainStateRootInvalid

Emits when the core domain block state root is invalid.

-
§

UnableToSubmitCrossDomainMessage(TrySendError<Message>)

Failed to submit a cross domain message

+
§

UnableToSubmitCrossDomainMessage(TrySendError<Message>)

Failed to submit a cross domain message

§

InvalidChainId

Invalid ChainId

Trait Implementations§

source§

impl Debug for Error

source§

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

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

impl From<ApiError> for Error

source§

fn from(err: ApiError) -> Self

Converts to this type from the input type.
source§

impl From<ArithmeticError> for Error

source§

fn from(err: ArithmeticError) -> Self

Converts to this type from the input type.
source§

impl From<Error> for Error

source§

fn from(err: Error) -> Self

Converts to this type from the input type.

Auto Trait Implementations§

§

impl !RefUnwindSafe for Error

§

impl Send for Error

§

impl Sync for Error

§

impl Unpin for Error

§

impl !UnwindSafe for Error

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_client_message_relayer/type.GossipMessageSink.html b/domain_client_message_relayer/type.GossipMessageSink.html index b7901ff675..abe22d23bf 100644 --- a/domain_client_message_relayer/type.GossipMessageSink.html +++ b/domain_client_message_relayer/type.GossipMessageSink.html @@ -1,3 +1,3 @@ GossipMessageSink in domain_client_message_relayer - Rust
-

Type Alias domain_client_message_relayer::GossipMessageSink

source · 
pub type GossipMessageSink = TracingUnboundedSender<Message>;
Expand description

Sink used to submit all the gossip messages.

+

Type Alias domain_client_message_relayer::GossipMessageSink

source · 
pub type GossipMessageSink = TracingUnboundedSender<Message>;
Expand description

Sink used to submit all the gossip messages.

Aliased Type§

struct GossipMessageSink { /* private fields */ }
\ No newline at end of file diff --git a/domain_client_operator/struct.Operator.html b/domain_client_operator/struct.Operator.html index ad53cbbb11..d66a658b9d 100644 --- a/domain_client_operator/struct.Operator.html +++ b/domain_client_operator/struct.Operator.html @@ -15,7 +15,7 @@ Client: HeaderBackend<Block> + BlockBackend<Block> + AuxStore + ProvideRuntimeApi<Block> + ProofProvider<Block> + Finalizer<Block, Backend> + 'static, Client::Api: DomainCoreApi<Block> + MessengerApi<Block, NumberFor<Block>> + BlockBuilder<Block> + ApiExt<Block> + TaggedTransactionQueue<Block>, CClient: HeaderBackend<CBlock> + HeaderMetadata<CBlock, Error = Error> + BlockBackend<CBlock> + ProvideRuntimeApi<CBlock> + ProofProvider<CBlock> + BlockchainEvents<CBlock> + Send + Sync + 'static, - CClient::Api: DomainsApi<CBlock, Block::Header> + MessengerApi<CBlock, NumberFor<CBlock>> + BundleProducerElectionApi<CBlock, Balance> + FraudProofApi<CBlock, Block::Header>, + CClient::Api: DomainsApi<CBlock, Block::Header> + MessengerApi<CBlock, NumberFor<CBlock>> + BundleProducerElectionApi<CBlock, Balance> + FraudProofApi<CBlock, Block::Header>, Backend: Backend<Block> + Send + Sync + 'static, TransactionPool: TransactionPool<Block = Block> + 'static, E: CodeExecutor,

source

pub async fn new<IBNS, CIBNS, NSNS, ASS>( diff --git a/domain_eth_service/provider/struct.EthProvider.html b/domain_eth_service/provider/struct.EthProvider.html index 6869a310f5..06bf73a85d 100644 --- a/domain_eth_service/provider/struct.EthProvider.html +++ b/domain_eth_service/provider/struct.EthProvider.html @@ -6,10 +6,10 @@ ) -> Self

source

pub fn with_configuration( base_path: Option<&Path>, eth_config: EthConfiguration -) -> Self

Trait Implementations§

source§

impl<Block, RuntimeApi, CT, EC> BlockImportProvider<Block, Client<Backend<Block>, LocalCallExecutor<Block, Backend<Block>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block, RuntimeApi>> for EthProvider<CT, EC>
where +) -> Self

Trait Implementations§

source§

impl<Block, RuntimeApi, CT, EC> BlockImportProvider<Block, Client<Backend<Block>, LocalCallExecutor<Block, Backend<Block>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block, RuntimeApi>> for EthProvider<CT, EC>
where Block: BlockT, - RuntimeApi: ConstructRuntimeApi<Block, FullClient<Block, RuntimeApi>> + Send + Sync + 'static, - RuntimeApi::RuntimeApi: ApiExt<Block> + Core<Block> + BlockBuilder<Block> + EthereumRuntimeRPCApi<Block>,

§

type BI = FrontierBlockImport<Block, Arc<Client<Backend<Block>, LocalCallExecutor<Block, Backend<Block>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block, RuntimeApi>>, Client<Backend<Block>, LocalCallExecutor<Block, Backend<Block>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block, RuntimeApi>>

source§

fn block_import(&self, client: Arc<FullClient<Block, RuntimeApi>>) -> Self::BI

source§

impl<Block, Client, BE, TxPool, CA, AccountId, CT, EC, CIDP> RpcProvider<Block, Client, TxPool, CA, BE, AccountId, CIDP> for EthProvider<CT, EC>
where + RuntimeApi: ConstructRuntimeApi<Block, FullClient<Block, RuntimeApi>> + Send + Sync + 'static, + RuntimeApi::RuntimeApi: ApiExt<Block> + Core<Block> + BlockBuilder<Block> + EthereumRuntimeRPCApi<Block>,

§

type BI = FrontierBlockImport<Block, Arc<Client<Backend<Block>, LocalCallExecutor<Block, Backend<Block>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block, RuntimeApi>>, Client<Backend<Block>, LocalCallExecutor<Block, Backend<Block>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block, RuntimeApi>>

source§

fn block_import(&self, client: Arc<FullClient<Block, RuntimeApi>>) -> Self::BI

source§

impl<Block, Client, BE, TxPool, CA, AccountId, CT, EC, CIDP> RpcProvider<Block, Client, TxPool, CA, BE, AccountId, CIDP> for EthProvider<CT, EC>
where Block: BlockT<Hash = H256>, BE: Backend<Block> + 'static, Client: ProvideRuntimeApi<Block> + BlockchainEvents<Block> + StorageProvider<Block, BE> + HeaderBackend<Block> + CallApiAt<Block> + HeaderMetadata<Block, Error = Error> + BlockBackend<Block> + AuxStore + Send + Sync + 'static, @@ -19,12 +19,12 @@ TxPool: TransactionPool<Block = Block> + Sync + Send + 'static, CA: ChainApi<Block = Block> + 'static, AccountId: DeserializeOwned + Encode + Debug + Decode + Display + Clone + Sync + Send + 'static, - CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,

§

type Deps = EthDeps<Client, TxPool, CA, CT, Block, BE, CIDP>

source§

fn deps( + CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,

§

type Deps = EthDeps<Client, TxPool, CA, CT, Block, BE, CIDP>

source§

fn deps( &self, - full_deps: FullDeps<Block, Client, TxPool, CA, BE, CIDP> -) -> Result<Self::Deps, Error>

source§

fn rpc_id(&self) -> Option<Box<dyn RpcSubscriptionIdProvider>>

source§

fn rpc_builder<SE>( + full_deps: FullDeps<Block, Client, TxPool, CA, BE, CIDP> +) -> Result<Self::Deps, Error>

source§

fn rpc_id(&self) -> Option<Box<dyn RpcSubscriptionIdProvider>>

source§

fn rpc_builder<SE>( &self, - deps: Self::Deps, + deps: Self::Deps, subscription_task_executor: SubscriptionTaskExecutor, essential_task_spawner: SE ) -> Result<RpcModule<()>, Box<dyn Error + Send + Sync>>
where diff --git a/domain_service/fn.new_full.html b/domain_service/fn.new_full.html index 49b1442070..16fe7f802c 100644 --- a/domain_service/fn.new_full.html +++ b/domain_service/fn.new_full.html @@ -6,7 +6,7 @@ NumberFor<CBlock>: From<NumberFor<Block>> + Into<u32>, CBlock::Hash: From<Hash> + Into<Hash>, CClient: HeaderBackend<CBlock> + HeaderMetadata<CBlock, Error = Error> + BlockBackend<CBlock> + ProofProvider<CBlock> + ProvideRuntimeApi<CBlock> + BlockchainEvents<CBlock> + Send + Sync + 'static, - CClient::Api: DomainsApi<CBlock, Header> + RelayerApi<CBlock, NumberFor<CBlock>> + MessengerApi<CBlock, NumberFor<CBlock>> + BundleProducerElectionApi<CBlock, Balance> + FraudProofApi<CBlock, Header>, + CClient::Api: DomainsApi<CBlock, Header> + RelayerApi<CBlock, NumberFor<CBlock>> + MessengerApi<CBlock, NumberFor<CBlock>> + BundleProducerElectionApi<CBlock, Balance> + FraudProofApi<CBlock, Header>, IBNS: Stream<Item = (NumberFor<CBlock>, Sender<()>)> + Send + 'static, CIBNS: Stream<Item = BlockImportNotification<CBlock>> + Send + 'static, NSNS: Stream<Item = (Slot, Randomness)> + Send + 'static, diff --git a/domain_service/struct.DomainParams.html b/domain_service/struct.DomainParams.html index f6e066641e..f3de4ab976 100644 --- a/domain_service/struct.DomainParams.html +++ b/domain_service/struct.DomainParams.html @@ -9,12 +9,12 @@ pub consensus_network: Arc<CNetwork>, pub consensus_offchain_tx_pool_factory: OffchainTransactionPoolFactory<CBlock>, pub consensus_network_sync_oracle: Arc<dyn SyncOracle + Send + Sync>, - pub operator_streams: OperatorStreams<CBlock, IBNS, CIBNS, NSNS, ASS>, + pub operator_streams: OperatorStreams<CBlock, IBNS, CIBNS, NSNS, ASS>, pub gossip_message_sink: GossipMessageSink, - pub domain_message_receiver: TracingUnboundedReceiver<ChainTxPoolMsg>, + pub domain_message_receiver: TracingUnboundedReceiver<ChainTxPoolMsg>, pub provider: Provider, pub skip_empty_bundle_production: bool, -

}

Fields§

§domain_id: DomainId§domain_config: Configuration§domain_created_at: NumberFor<CBlock>§maybe_operator_id: Option<OperatorId>§consensus_client: Arc<CClient>§consensus_network: Arc<CNetwork>§consensus_offchain_tx_pool_factory: OffchainTransactionPoolFactory<CBlock>§consensus_network_sync_oracle: Arc<dyn SyncOracle + Send + Sync>§operator_streams: OperatorStreams<CBlock, IBNS, CIBNS, NSNS, ASS>§gossip_message_sink: GossipMessageSink§domain_message_receiver: TracingUnboundedReceiver<ChainTxPoolMsg>§provider: Provider§skip_empty_bundle_production: bool

Auto Trait Implementations§

§

impl<CBlock, CClient, IBNS, CIBNS, NSNS, ASS, Provider, CNetwork> !RefUnwindSafe for DomainParams<CBlock, CClient, IBNS, CIBNS, NSNS, ASS, Provider, CNetwork>

§

impl<CBlock, CClient, IBNS, CIBNS, NSNS, ASS, Provider, CNetwork> Send for DomainParams<CBlock, CClient, IBNS, CIBNS, NSNS, ASS, Provider, CNetwork>
where +}

Fields§

§domain_id: DomainId§domain_config: Configuration§domain_created_at: NumberFor<CBlock>§maybe_operator_id: Option<OperatorId>§consensus_client: Arc<CClient>§consensus_network: Arc<CNetwork>§consensus_offchain_tx_pool_factory: OffchainTransactionPoolFactory<CBlock>§consensus_network_sync_oracle: Arc<dyn SyncOracle + Send + Sync>§operator_streams: OperatorStreams<CBlock, IBNS, CIBNS, NSNS, ASS>§gossip_message_sink: GossipMessageSink§domain_message_receiver: TracingUnboundedReceiver<ChainTxPoolMsg>§provider: Provider§skip_empty_bundle_production: bool

Auto Trait Implementations§

§

impl<CBlock, CClient, IBNS, CIBNS, NSNS, ASS, Provider, CNetwork> !RefUnwindSafe for DomainParams<CBlock, CClient, IBNS, CIBNS, NSNS, ASS, Provider, CNetwork>

§

impl<CBlock, CClient, IBNS, CIBNS, NSNS, ASS, Provider, CNetwork> Send for DomainParams<CBlock, CClient, IBNS, CIBNS, NSNS, ASS, Provider, CNetwork>
where ASS: Send, CClient: Sync + Send, CIBNS: Send, diff --git a/domain_service/type.DomainOperator.html b/domain_service/type.DomainOperator.html index 5a66cc6285..bcc4da8be9 100644 --- a/domain_service/type.DomainOperator.html +++ b/domain_service/type.DomainOperator.html @@ -1,5 +1,5 @@ DomainOperator in domain_service - Rust
-

Type Alias domain_service::DomainOperator

source · 
pub type DomainOperator<Block, CBlock, CClient, RuntimeApi> = Operator<Block, CBlock, FullClient<Block, RuntimeApi>, CClient, FullPool<CBlock, CClient, RuntimeApi>, FullBackend<Block>, RuntimeExecutor>;

Aliased Type§

struct DomainOperator<Block, CBlock, CClient, RuntimeApi> {
+    
Type Alias domain_service::DomainOperator
source · 
pub type DomainOperator<Block, CBlock, CClient, RuntimeApi> = Operator<Block, CBlock, FullClient<Block, RuntimeApi>, CClient, FullPool<CBlock, CClient, RuntimeApi>, FullBackend<Block>, RuntimeExecutor>;
Aliased Type§
struct DomainOperator<Block, CBlock, CClient, RuntimeApi> {
     pub transaction_pool: Arc<BasicPool<FullChainApiWrapper<CClient, CBlock, 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 */
diff --git a/domain_test_service/domain/type.DomainOperator.html b/domain_test_service/domain/type.DomainOperator.html
index 76850bb5f0..c7ac30db50 100644
--- a/domain_test_service/domain/type.DomainOperator.html
+++ b/domain_test_service/domain/type.DomainOperator.html
@@ -1,7 +1,7 @@
 DomainOperator in domain_test_service::domain - Rust

     
Type Alias domain_test_service::domain::DomainOperator
source · 
pub type DomainOperator<RuntimeApi> = DomainOperator<Block, Block, Client, RuntimeApi>;
Expand description
Domain executor for the test service.

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

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

\ No newline at end of file
diff --git a/domain_test_service/domain/type.EvmDomainNode.html b/domain_test_service/domain/type.EvmDomainNode.html
index 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..b447cc1617 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..597f4a7a79 100644 --- a/index.html +++ b/index.html @@ -1,2 +1,2 @@ -Index of crates
-

List of all crates

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

List of all crates

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

Function pallet_domains::dispatchables::submit_fraud_proof

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

Warning: Doc-Only

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

}
Expand description

Contains a variant per dispatchable extrinsic that this pallet has.

Variants§

§

submit_bundle

Fields

§opaque_bundle: OpaqueBundleOf<T>

See Pallet::submit_bundle.

-
§

submit_fraud_proof

Fields

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

See Pallet::submit_fraud_proof.

+
§

submit_fraud_proof

Fields

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

See Pallet::submit_fraud_proof.

§

register_domain_runtime

Fields

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

See Pallet::register_domain_runtime.

§

upgrade_domain_runtime

Fields

§runtime_id: RuntimeId
§raw_genesis_storage: Vec<u8>

See Pallet::upgrade_domain_runtime.

§

register_operator

Fields

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

See Pallet::register_operator.

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

force_staking_epoch_transition

Fields

§domain_id: DomainId

See Pallet::force_staking_epoch_transition.

Implementations§

source§

impl<T: Config> Call<T>

source

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

Create a call with the variant submit_bundle.

source

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

Create a call with the variant submit_fraud_proof.

source

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

source§

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

source

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

source

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

source§

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

source

pub fn submit_bundle_unsigned(opaque_bundle: OpaqueBundleOf<T>)

Submits an unsigned extrinsic Call::submit_bundle.

source

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

Submits an unsigned extrinsic Call::submit_fraud_proof.

Trait Implementations§

source§

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

source§

fn before_all_runtime_migrations() -> Weight

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

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

§

type RuntimeCall = Call<T>

source§

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Self

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

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

Performs copy-assignment from source. Read more
source§

impl<T> Debug for Pallet<T>

source§

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

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

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

§

type CurrentStorageVersion = StorageVersion

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

fn current_storage_version() -> Self::CurrentStorageVersion

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

fn on_chain_storage_version() -> StorageVersion

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

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

source§

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

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

fn on_finalize(_: BlockNumberFor<T>)

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

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

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

fn on_runtime_upgrade() -> Weight

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

fn offchain_worker(_n: BlockNumber)

Implementing this function on a pallet allows you to perform long-running tasks that are diff --git a/pallet_rewards/trait.Config.html b/pallet_rewards/trait.Config.html index 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 7a2c681735..696f3d6a43 100644 --- a/search-index.js +++ b/search-index.js @@ -45,8 +45,8 @@ 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":"GFSIIIIFPTPFFFTTTTTTTTTFGTTTSPFFFFFFFFFFFSSSFFFFFFFFTTTTTTTTTTTTTTTFIFFGFIFIFPTTTTNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOCNNNNNNNNNNNNNNNNNNNNNNNNNONNOONNONONONNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOFNNNNNNNNNNNNNNNNNNNNNNNTTFNNHHHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNFSFSSFFNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNGFGGFPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOO","n":["ArchivedBlockProgress","ArchivedHistorySegment","BLAKE3_HASH_SIZE","Blake3Hash","BlockHash","BlockNumber","BlockWeight","ChunkWitness","Complete","ERASURE_CODING_RATE","EmptyVec","FlatPieces","HistorySize","LastArchivedBlock","MAX","MAX","MIDDLE","NUM_CHECKPOINTS","NUM_CHUNKS","NUM_CHUNKS","NUM_PIECES","NUM_RAW_RECORDS","NUM_S_BUCKETS","NonEmptyVec","NonEmptyVecErr","ONE","ONE","ONE","PUBLIC_KEY_LENGTH","Partial","Piece","PieceArray","PieceIndex","PieceOffset","PosProof","PosSeed","PotCheckpoints","PotKey","PotOutput","PotSeed","PublicKey","RANDOMNESS_LENGTH","REWARD_SIGNATURE_LENGTH","REWARD_SIGNING_CONTEXT","Randomness","RawRecord","Record","RecordCommitment","RecordWitness","RecordedHistorySegment","RewardSignature","SBucket","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SIZE","SectorId","SectorIndex","SectorSlotChallenge","SegmentCommitment","SegmentHeader","SegmentIndex","SlotNumber","Solution","SolutionRange","U256","V0","ZERO","ZERO","ZERO","ZERO","add","add","add","add","add","add_assign","add_assign","add_assign","add_assign","archived_progress","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_byte_slice","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_byte_slice","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_mut_slice_of","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_ref","as_slice","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","as_slice_of","backward_checked","backward_checked","backward_checked","backward_checked","bidirectional_distance","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","checked_add","checked_div","checked_mul","checked_sub","checksum","chunk","chunk_witness","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","cmp","commitment","commitment_mut","crypto","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_into","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","default","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","derive_evaluation_seed","derive_expiration_history_size","derive_global_challenge","derive_global_randomness","derive_piece_index","derive_sector_slot_challenge","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","deserialize","div","div","div","div","div","div_assign","div_assign","div_assign","div_assign","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","drop","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_hex_upper","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","encode_to","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","eq","first","first_piece_index","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","forward_checked","forward_checked","forward_checked","forward_checked","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from","from_be_bytes","from_bytes","from_genesis","from_hex","from_hex","from_hex","from_le_bytes","from_str","genesis_solution","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","hash","history_size","in_pieces","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","init","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into","into_inner","into_reward_address_format","iter","iter_mut","key","last","last_archived_block","last_piece_index","len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","max_encoded_len","mul","mul","mul","mul","mul","mul_assign","mul_assign","mul_assign","mul_assign","new","new","new","new","new_boxed","new_boxed","new_boxed","new_boxed","new_with_entry","new_zero_vec","number","objects","one","output","par_parity","par_parity_mut","par_source","par_source_mut","parity","parity_mut","partial","partial_archived","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","piece_offset","position","prev_segment_header_hash","proof_of_space","public_key","push","record","record_commitment","record_mut","record_witness","rem","reward_address","s_bucket_audit_index","saturating_add","saturating_mul","saturating_sub","sector_expiration_check","sector_index","seed","seed_with_entropy","segment_commitment","segment_index","segment_index","segment_index","segment_piece_indexes","segment_piece_indexes_source_first","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","serialize","set_complete","set_partial","set_partial_archived","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","size_hint","slice_from_repr","slice_mut_from_repr","slice_mut_to_repr","slice_to_repr","source","source_mut","split","split_mut","steps_between","steps_between","steps_between","steps_between","sub","sub","sub","sub","sub","sub_assign","sub_assign","sub_assign","sub_assign","to_be_bytes","to_bytes","to_bytes","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_le_bytes","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_string","to_vec","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_id","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","type_info","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","using_encoded","witness","witness_mut","wrapping_add","wrapping_sub","zero","last_archived_block","prev_segment_header_hash","segment_commitment","segment_index","Blake3Checksummed","borrow","borrow_mut","clone","clone_into","decode","decode_all","decode_all_with_depth_limit","decode_with_depth_limit","deref","deref_mut","drop","encode_to","encoded_size","fmt","from","init","into","size_hint","to_keyed_vec","to_owned","try_from","try_into","type_id","FULL_BYTES","SAFE_BYTES","Scalar","as_mut","as_ref","blake3_254_hash_to_scalar","blake3_hash","blake3_hash_list","blake3_hash_parallel","blake3_hash_with_key","borrow","borrow_mut","clone","clone_into","cmp","decode","decode_all","decode_all_with_depth_limit","decode_with_depth_limit","default","deref","deref","deref_mut","deref_mut","deserialize","drop","encoded_fixed_size","encoded_size","eq","fmt","from","from","from","from","hash","init","into","kzg","max_encoded_len","partial_cmp","serialize","size_hint","slice_from_repr","slice_mut_from_repr","slice_mut_to_repr","slice_option_from_repr","slice_option_mut_from_repr","slice_option_mut_to_repr","slice_option_to_repr","slice_to_repr","to_bytes","to_keyed_vec","to_owned","try_from","try_from","try_from","try_into","type_id","type_info","using_encoded","vec_from_repr","vec_option_from_repr","vec_option_to_repr","vec_to_repr","Commitment","EMBEDDED_KZG_SETTINGS_BYTES","Kzg","NUM_G1_POWERS","NUM_G2_POWERS","Polynomial","Witness","as_mut","as_mut","as_ref","as_ref","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","bytes_to_kzg_settings","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","commit","create_witness","default","default","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","drop","drop","drop","drop","embedded_kzg_settings","eq","eq","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","get_fft_settings","init","init","init","init","into","into","into","into","new","normalize","poly","slice_from_repr","slice_mut_from_repr","slice_mut_to_repr","slice_option_from_repr","slice_option_mut_from_repr","slice_option_mut_to_repr","slice_option_to_repr","slice_to_repr","to_bytes","to_bytes","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_from_bytes","try_from_bytes","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","vec_from_repr","vec_option_from_repr","vec_option_to_repr","vec_to_repr","verify","BlockObject","BlockObjectMapping","GlobalObject","PieceObject","PieceObjectMapping","V0","V0","V0","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","cmp","cmp","cmp","cmp","cmp","decode","decode","decode","decode","decode","decode_all","decode_all","decode_all","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","default","default","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deserialize","deserialize","deserialize","deserialize","deserialize","drop","drop","drop","drop","drop","encode","encode","encode_to","encode_to","encode_to","encode_to","encode_to","eq","eq","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","hash","hash","hash","hash","hash","hash","hash","init","init","init","init","init","into","into","into","into","into","objects","objects","offset","offset","offset","partial_cmp","partial_cmp","partial_cmp","partial_cmp","partial_cmp","piece_index","serialize","serialize","serialize","serialize","serialize","set_offset","size_hint","size_hint","size_hint","size_hint","size_hint","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_keyed_vec","to_owned","to_owned","to_owned","to_owned","to_owned","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_info","type_info","type_info","type_info","type_info","using_encoded","using_encoded","hash","offset","offset","piece_index","hash","offset"],"q":[[0,"subspace_core_primitives"],[1415,"subspace_core_primitives::SegmentHeader"],[1419,"subspace_core_primitives::checksum"],[1443,"subspace_core_primitives::crypto"],[1507,"subspace_core_primitives::crypto::kzg"],[1626,"subspace_core_primitives::objects"],[1794,"subspace_core_primitives::objects::BlockObject"],[1796,"subspace_core_primitives::objects::GlobalObject"],[1798,"subspace_core_primitives::objects::PieceObject"],[1800,"byte_slice_cast"],[1801,"core::result"],[1802,"byte_slice_cast"],[1803,"core::option"],[1804,"num_traits::ops::wrapping"],[1805,"core::cmp"],[1806,"core::cmp"],[1807,"parity_scale_codec::codec"],[1808,"parity_scale_codec::codec"],[1809,"parity_scale_codec::decode_finished"],[1810,"serde::de"],[1811,"serde::de"],[1812,"core::iter::traits::collect"],[1813,"parity_scale_codec::codec"],[1814,"parity_scale_codec::codec"],[1815,"core::fmt"],[1816,"core::convert"],[1817,"core::hash"],[1818,"core::convert"],[1819,"alloc::boxed"],[1820,"rayon::iter"],[1821,"core::iter::traits::exact_size"],[1822,"serde::ser"],[1823,"serde::ser"],[1824,"core::any"],[1825,"scale_info::ty"],[1826,"core::ops::function"],[1827,"rust_kzg_blst::types::fr"],[1828,"rust_kzg_blst::types::g1"],[1829,"rust_kzg_blst::types::kzg_settings"],[1830,"rust_kzg_blst::types::poly"],[1831,"rust_kzg_blst::types::fft_settings"],[1832,"alloc::sync"]],"d":["Progress of an archived block.","Archived history segment after archiving is applied.","Size of BLAKE3 hash output (in bytes).","BLAKE3 hash output","Block hash in Subspace network.","Block number in Subspace network.","BlockWeight type for fork choice rules.","Witness for chunk contained within a record.","The block has been fully archived.","Erasure coding rate for records during archiving process.","Tried to create with an empty Vec","Flat representation of multiple pieces concatenated for …","Size of blockchain history in segments.","Last archived block","Max s-bucket index","Maximum value.","The middle of the piece distance field. The analogue of …","Number of PoT checkpoints produced (used to optimize …","Number of chunks (scalars) within one raw record.","Number of chunks (scalars) within one record.","Number of pieces in one segment of archived history.","Number of raw records in one segment of recorded history.","Number of s-buckets contained within one record (and by …","A Vec<> that enforces the invariant that it cannot be …","Error codes for NonEmptyVec.","Piece index 1.","Piece index 1.","Segment index 1.","Length of public key in bytes.","Number of partially archived bytes of a block.","A piece of archival history in Subspace Network.","A piece of archival history in Subspace Network.","Piece index in consensus","Piece offset in sector","Proof of space proof bytes.","Proof of space seed.","Proof of time checkpoints, result of proving","Proof of time key(input to the encryption).","Proof of time output, can be intermediate checkpoint or …","Proof of time seed","A Ristretto Schnorr public key as bytes produced by …","Byte length of a randomness type.","Length of signature in bytes","Signing context used for creating reward signatures by …","Type of randomness.","Raw record contained within recorded history segment …","Record contained within a piece.","Record commitment contained within a piece.","Record witness contained within a piece.","Recorded history segment before archiving is applied.","A Ristretto Schnorr signature as bytes produced by …","S-bucket used in consensus","Size in bytes.","Size of raw record in bytes, is guaranteed to be a …","Size of a segment record given the global piece size (in …","Size of record commitment in bytes.","Size of record witness in bytes.","Size of chunk witness in bytes.","Size of a piece (in bytes).","Size of segment commitment in bytes.","Size of recorded history segment in bytes.","Size of archived history segment in bytes.","Size of proof of space seed in bytes.","Size of proof of space proof in bytes.","Size of proof of time key in bytes","Size of proof of time seed in bytes","Size of proof of time proof in bytes","Data structure representing sector ID in farmer’s plot","Sector index in consensus","Challenge used for a particular sector for particular slot","Segment commitment contained within segment header.","Segment header for a specific segment.","Segment index type.","Slot number in Subspace network.","Farmer solution for slot challenge.","Type of solution range.","256-bit unsigned integer","V0 of the segment header data structure","S-bucket 0.","Piece index 0.","Piece index 0.","Segment index 0.","","","","","","","","","","Progress of an archived block.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the slice of the entries.","","","","","","","","","","","","","","","","","","","Bidirectional distance metric implemented on top of …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Adds two numbers, checking for overflow. If overflow …","Divides two numbers, checking for underflow, overflow and …","Multiplies two numbers, checking for underflow or …","Subtracts two numbers, checking for underflow. If …","Module containing wrapper for SCALE encoding/decoding with …","Chunk at above offset","Witness for above chunk","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Commitment contained within a piece.","Mutable commitment contained within a piece.","Various cryptographic utilities used across Subspace …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","We assume a block can always fit into the segment …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Derive evaluation seed","Derive history size when sector created at history_size …","Derive global slot challenge from global randomness.","Derives the global randomness from the output","Derive piece index that should be stored in sector at …","Derive sector slot challenge for this sector from provided …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the first entry.","Get the first piece index in this segment.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","Returns the argument unchanged.","","","Returns the argument unchanged.","","","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","","","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Create from big endian bytes","Create piece index from bytes.","Derive initial PoT seed from genesis block hash","","","","Create from little endian bytes","","Dummy solution for the genesis block","","","","","","","","","","","","","Proof hash.","","","","","Public key hash.","","","","Hash of the whole segment header","","","","","Size of the blockchain history at time of sector creation","Size of blockchain history in pieces.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Extract internal representation.","Transform solution with one reward address type into …","Returns an iterator for the entries.","Returns a mutable iterator for the entries.","Derive key from proof of time seed","Returns the last entry.","Last archived block","Get the last piece index in this segment.","Returns the number of entries.","","","","","","","","","","","","","","","","","","","","","","","","","","","Allocate FlatPieces that will hold piece_count pieces …","Create new instance.","Create new sector ID by deriving it from public key and …","Creates the Vec.","Create boxed value without hitting stack overflow","Create boxed value without hitting stack overflow","Create boxed value without hitting stack overflow","Create boxed value without hitting stack overflow","Creates the Vec with the entry.","Create vector filled with zeroe records without hitting …","Block number","Data structures related to objects (useful data) stored on …","One (multiplicative identity) of this type.","Get proof of time output out of checkpoints (last …","Parallel iterator over parity pieces (odd indices).","Mutable parallel iterator over parity pieces (odd indices).","Parallel iterator over source pieces (even indices).","Mutable parallel iterator over source pieces (even …","Iterator over parity pieces (odd indices).","Mutable iterator over parity pieces (odd indices).","Return the number of partially archived bytes if the …","Returns the number of partially archived bytes for a block.","","","","","","","","","","","","","","","","Pieces offset within sector","Position of a piece in a segment","Hash of the segment header of the previous segment","Proof of space for piece offset","Public key of the farmer that created the solution","Adds an entry to the end.","Record contained within a piece.","Record commitment that can use used to verify that piece …","Mutable record contained within a piece.","Witness for above record commitment","","Address for receiving block reward","Index of s-bucket within sector to be audited","Saturating addition. Computes self + other, saturating at …","Saturating multiplication. Computes self * other, …","Saturating subtraction. Computes self - other, saturating …","History size at which expiration check for sector happens.","Index of the sector where solution was found","Derive seed from proof of time in case entropy injection …","Derive seed from proof of time with entropy injection","Segment commitment of the records in a segment.","Segment index piece index corresponds to","Segment index that corresponds to this history size.","Segment index","List of piece indexes that belong to this segment.","List of piece indexes that belong to this segment with …","","","","","","","","","","","","","","","","","","","","","","","","","","Sets the archived state of this block to …","Sets new number of partially archived bytes.","Sets new number of partially archived bytes.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Convenient conversion from slice of underlying …","Convenient conversion from mutable slice of underlying …","Convenient conversion from mutable slice of record to …","Convenient conversion from slice of record to underlying …","Iterator over source pieces (even indices).","Mutable iterator over source pieces (even indices).","Split piece into underlying components.","Split piece into underlying mutable components.","","","","","","","","","","","","","","Convert to big endian bytes","Convert piece index to bytes.","Convert piece offset to bytes.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Convert to little endian bytes","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the entries in the collection.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Witness contained within a piece.","Mutable witness contained within a piece.","","","Zero (additive identity) of this type.","Last archived block","Hash of the segment header of the previous segment","Root of commitments of all records in a segment.","Segment index","Wrapper data structure that when encoded/decoded will …","","","","","","","","","","","","","","","Returns the argument unchanged.","","Calls U::from(self).","","","","","","","How many bytes Scalar contains physically, use …","How many full bytes can be stored in BLS12-381 scalar (for …","Representation of a single BLS12-381 scalar value.","","","BLAKE3 hashing of a single value truncated to 254 bits.","BLAKE3 hashing of a single value.","BLAKE3 hashing of a list of values.","BLAKE3 hashing of a single value in parallel (only useful …","BLAKE3 keyed hashing of a single value.","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","","","Calls U::from(self).","Tools for KZG commitment scheme","","","","","Convenient conversion from slice of underlying …","Convenient conversion from mutable slice of underlying …","Convenient conversion from mutable slice of scalar to …","Convenient conversion from slice of optional underlying …","Convenient conversion from optional mutable slice of …","Convenient conversion from optional mutable slice of …","Convenient conversion from slice of optional scalar to …","Convenient conversion from slice of scalar to underlying …","Convert scalar into bytes","","","","","","","","","","Convenient conversion from vector of underlying …","Convenient conversion from vector of optional underlying …","Convenient conversion from vector of optional scalar to …","Convenient conversion from vector of scalar to underlying …","Commitment to polynomial","Embedded KZG settings as bytes, too big for no_std in most …","Wrapper data structure for working with KZG commitment …","Number of G1 powers stored in EMBEDDED_KZG_SETTINGS_BYTES","Number of G2 powers stored in EMBEDDED_KZG_SETTINGS_BYTES","Commitment to polynomial","Witness for polynomial evaluation","","","","","","","","","","","","","Function turns bytes into FsKZGSettings, it is up to the …","","","","","","","","","Computes a Commitment to polynomial","Computes a Witness of evaluation of polynomial at index","","","","","","","","","","","","","","","","","","","Embedded KZG settings","","","","","","","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","Get FFT settings for specified number of values, uses …","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Create new instance with given KZG settings.","Normalize polynomial by removing trailing zeroes","Create polynomial from data. Data must be multiple of 32 …","Convenient conversion from slice of underlying …","Convenient conversion from mutable slice of underlying …","Convenient conversion from mutable slice of commitment to …","Convenient conversion from slice of optional underlying …","Convenient conversion from optional mutable slice of …","Convenient conversion from optional mutable slice of …","Convenient conversion from slice of optional commitment to …","Convenient conversion from slice of commitment to …","Convert commitment to raw bytes","Convert witness to raw bytes","","","","","","","","","","","","","","","","","","","","","Try to deserialize commitment from raw bytes","Try to deserialize witness from raw bytes","","","","","","","","","Convenient conversion from vector of underlying …","Convenient conversion from vector of optional underlying …","Convenient conversion from vector of optional commitment …","Convenient conversion from vector of commitment to …","Verifies that value is the evaluation at index of the …","Object stored inside of the block","Mapping of objects stored inside of the block","Object stored inside in the history of the blockchain","Object stored inside of the block","Mapping of objects stored inside of the piece","V0 of object mapping data structure","V0 of object mapping data structure","V0 of object mapping data structure","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Object hash","","","Object hash","","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Objects stored inside of the block","Objects stored inside of the block","Offset of object in the encoded block.","Offset of the object","Offset of the object","","","","","","Piece index where object is contained (at least its …","","","","","","Sets new offset.","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Object hash","Offset of object in the encoded block.","Offset of the object","Piece index where object is contained (at least its …","Object hash","Offset of the object"],"i":[0,0,0,0,0,0,0,0,41,19,70,0,0,0,1,5,5,40,9,10,37,19,10,0,0,2,3,4,0,41,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,9,10,11,12,13,14,18,19,37,38,39,21,22,23,0,0,0,0,0,0,0,0,0,0,43,1,2,3,4,1,2,3,4,5,1,2,3,4,42,9,10,11,12,13,14,15,17,18,19,20,27,28,29,9,10,11,12,13,14,15,15,17,18,19,20,21,22,23,9,10,11,12,13,14,15,17,18,19,20,9,10,11,12,13,14,15,17,18,19,20,9,10,11,12,13,14,15,15,17,18,19,20,21,22,23,27,28,29,30,9,10,11,12,13,14,15,17,18,19,20,27,28,29,1,2,3,4,0,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,5,5,5,5,0,44,44,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,1,2,3,14,15,17,4,36,27,28,41,42,5,45,29,15,15,0,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,11,12,13,15,4,18,36,37,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,9,10,11,12,13,14,15,17,4,18,19,37,20,39,21,22,23,40,27,41,5,1,2,3,9,9,10,10,11,11,12,12,13,13,14,14,15,15,17,17,4,18,18,36,36,19,19,37,37,20,20,38,38,39,39,21,21,22,22,23,23,40,40,27,27,28,28,41,42,43,44,5,45,45,29,30,70,1,2,3,9,9,10,10,11,11,12,12,13,13,14,14,15,15,17,17,4,18,18,36,36,19,19,37,37,20,38,39,39,21,21,22,22,23,23,40,40,27,28,41,42,43,44,5,45,29,30,70,29,29,20,23,29,29,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,27,28,41,42,43,44,29,1,2,3,4,5,1,2,3,4,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,5,29,30,9,10,11,12,13,14,15,17,18,19,20,27,28,29,9,10,11,12,13,14,15,17,18,19,20,27,28,29,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,30,4,1,1,2,2,3,3,9,10,11,12,13,14,15,17,4,4,18,36,36,19,37,20,38,39,21,21,22,22,23,23,40,27,27,28,41,42,43,44,5,5,45,29,30,70,1,2,3,4,1,1,2,2,3,3,9,10,11,11,11,12,12,12,13,13,13,14,14,15,17,17,4,4,18,18,18,36,36,36,19,37,20,20,38,38,39,39,21,21,22,22,23,23,40,27,27,28,28,41,42,43,44,5,5,5,5,5,5,45,29,30,70,5,2,22,15,17,39,5,21,44,1,2,3,11,12,13,14,15,17,4,18,36,39,22,23,40,27,27,28,41,42,43,43,5,45,29,44,36,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,17,44,30,30,22,30,43,4,30,1,2,3,11,12,13,15,4,18,36,37,20,39,21,22,23,40,1,2,3,4,5,1,2,3,4,17,36,29,30,9,10,15,19,30,10,42,0,5,40,17,17,17,17,17,17,41,42,1,2,3,14,15,17,4,36,27,28,41,42,5,45,29,44,2,43,44,44,30,15,44,15,44,5,44,45,5,5,5,36,44,23,23,43,2,36,43,4,4,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,27,28,41,42,43,44,29,42,41,42,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,10,10,10,10,17,17,15,15,1,2,3,4,1,2,3,4,5,1,2,3,4,5,2,3,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,30,5,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,1,2,3,4,36,21,22,23,27,5,30,1,1,2,3,9,10,11,11,12,12,13,13,14,14,14,15,17,4,18,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,9,10,11,12,13,14,15,17,4,18,36,19,37,20,38,39,21,22,23,40,27,28,41,42,43,44,5,45,29,30,70,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,41,42,43,44,5,29,1,2,3,11,12,13,14,15,17,4,18,36,37,20,39,21,22,23,40,27,28,5,29,30,15,15,5,5,5,109,109,109,109,0,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,94,95,95,0,95,95,0,0,0,0,0,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,0,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,95,0,0,0,0,0,0,0,72,73,72,73,99,72,73,100,99,72,73,100,0,99,72,73,100,99,72,73,100,100,100,72,73,99,72,72,73,73,100,99,72,72,73,73,100,99,72,73,100,0,72,73,99,72,73,100,99,99,72,72,73,73,100,100,99,72,73,100,99,72,73,100,100,99,100,72,72,72,72,72,72,72,72,72,73,99,72,73,100,99,72,72,72,72,72,72,72,73,73,73,73,73,73,73,100,72,73,99,72,73,100,99,72,73,100,72,72,72,72,100,0,0,0,0,0,104,106,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,104,105,106,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,104,106,108,104,105,106,107,108,108,104,105,106,107,108,104,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,104,105,106,107,108,105,107,110,110,111,111,112,112],"f":"``````````````````````````````````````````````````````````````````````````````````{{bb}b}{{dd}d}{{ff}f}{{hh}h}{{jj}j}{{bb}l}{{dd}l}{{ff}l}{{hh}l}`{c{{A`{n}}}{}}0000000000000{Ab{{A`{n}}}}{Ad{{A`{n}}}}{Af{{A`{n}}}}{Ah{{A`{n}}}}{Aj{{A`{n}}}}{Al{{A`{n}}}}{An{{B`{n}}}}{An{{A`{n}}}}{Bb{{A`{n}}}}{Bd{{A`{n}}}}{Bf{{A`{n}}}}{Bh{{A`{n}}}}{Bj{{B`{n}}}}{Bl{{B`{n}}}}{Bn{{B`{n}}}}???????????{c{{Cb{{A`{e}}C`}}}{}Cd}0000000000?>=<;:987654321{Cf{{A`{n}}}}{Ch{{A`{n}}}}{Cj{{A`{n}}}}{{{Cl{c}}}{{A`{c}}}Cn}44444444444444{{bD`}{{Db{b}}}}{{dD`}{{Db{d}}}}{{fD`}{{Db{f}}}}{{hD`}{{Db{h}}}}{{cc}c{DdDf}}{ce{}{}}0000000000000000000000000000000000000000000000000000000000000000000{{jj}{{Db{j}}}}000```{bb}{dd}{ff}{AbAb}{AdAd}{AfAf}{AhAh}{AjAj}{AlAl}{AnAn}{BbBb}{hh}{BdBd}{DhDh}{BfBf}{DjDj}{BhBh}{DlDl}{DnDn}{BjBj}{BlBl}{BnBn}{E`E`}{CfCf}{ChCh}{EbEb}{EdEd}{EfEf}{{{Eh{ce}}}{{Eh{ce}}}CnCn}{jj}{EjEj}{CjCj}{{{Cl{c}}}{{Cl{c}}}Cn}{{ce}l{}{}}00000000000000000000000000000000{{bb}El}{{dd}El}{{ff}El}{{AlAl}El}{{AnAn}El}{{BbBb}El}{{hh}El}{{DhDh}El}{{CfCf}El}{{ChCh}El}{{EbEb}El}{{EdEd}El}{{jj}El}{{EjEj}El}{{CjCj}El}{AnAf}0`{c{{Cb{bEn}}}F`}{c{{Cb{dEn}}}F`}{c{{Cb{fEn}}}F`}{c{{Cb{AfEn}}}F`}{c{{Cb{AhEn}}}F`}{c{{Cb{AjEn}}}F`}{c{{Cb{AlEn}}}F`}{c{{Cb{AnEn}}}F`}{c{{Cb{BbEn}}}F`}{c{{Cb{hEn}}}F`}{c{{Cb{BdEn}}}F`}{c{{Cb{DhEn}}}F`}{c{{Cb{DjEn}}}F`}{c{{Cb{BhEn}}}F`}{c{{Cb{DnEn}}}F`}{c{{Cb{BjEn}}}F`}{c{{Cb{BlEn}}}F`}{c{{Cb{BnEn}}}F`}{c{{Cb{E`En}}}F`}{c{{Cb{CfEn}}}F`}{c{{Cb{ChEn}}}F`}{c{{Cb{EbEn}}}F`}{c{{Cb{EdEn}}}F`}{c{{Cb{EfEn}}}F`}{c{{Cb{{Eh{eg}}En}}}F`FbFb}{c{{Cb{jEn}}}F`}{c{{Cb{CjEn}}}F`}{c{{Cb{{Cl{e}}En}}}F`{}}{{{A`{n}}}{{Cb{cEn}}}{}}000000000000000000000000000{{Fd{A`{n}}}{{Cb{cEn}}}{}}000000000000000000000000000{{c{Ff{b}}}{{Cb{FhEn}}}F`}{{c{Ff{d}}}{{Cb{FhEn}}}F`}{{c{Ff{f}}}{{Cb{FhEn}}}F`}{{c{Ff{Af}}}{{Cb{FhEn}}}F`}{{c{Ff{Ah}}}{{Cb{FhEn}}}F`}{{c{Ff{Aj}}}{{Cb{FhEn}}}F`}{{c{Ff{An}}}{{Cb{FhEn}}}F`}{{c{Ff{h}}}{{Cb{FhEn}}}F`}{{c{Ff{Bd}}}{{Cb{FhEn}}}F`}{{c{Ff{Dh}}}{{Cb{FhEn}}}F`}{{c{Ff{Dj}}}{{Cb{FhEn}}}F`}{{Fdc}{{Cb{eEn}}}F`{}}000000000000000000000000000{{}b}{{}d}{{}f}{{}Ab}{{}Ad}{{}Af}{{}Ah}{{}Aj}{{}Al}{{}An}{{}Bb}{{}h}{{}Bd}{{}Bf}{{}Dj}{{}Bh}{{}Dn}{{}Bj}{{}Bl}{{}Bn}{{}E`}{{}Cf}{{}Eb}{{}j}{D`c{}}000{Abc{}}{Adc{}}2{Afc{}}33{Ahc{}}{Ajc{}}55{Alc{}}{Anc{}}7{Bbc{}}888{Bdc{}}9{Dhc{}}{Bfc{}};;{Djc{}}<{Bhc{}}={Dlc{}}>{Dnc{}}{Bjc{}}{D`c{}}{Blc{}}1{Bnc{}}22{E`c{}}3{Cfc{}}{Chc{}}5555555{Ejc{}}666666{Abc{}}7{Adc{}}88{Afc{}}{Ahc{}}::{Ajc{}}{Alc{}}<{Anc{}}={Bbc{}}>>{Bdc{}}?{Dhc{}}{D`c{}}{Bfc{}}11{Djc{}}222{Dnc{}}{Bjc{}}44{Blc{}}5{Bnc{}}6{E`c{}}77777777777{{CjfDh}Dl}{{CjDhBdDh}{{Db{Dh}}}}{{BhFj}Fl}{BnBh}{{CjfDhFnDh{G`{DhDh}}}d}{{CjFl}Ej}{c{{Cb{b}}}Gb}{c{{Cb{d}}}Gb}{c{{Cb{f}}}Gb}{c{{Cb{Af}}}Gb}{c{{Cb{Ah}}}Gb}{c{{Cb{Aj}}}Gb}{c{{Cb{Al}}}Gb}{c{{Cb{An}}}Gb}{c{{Cb{Bb}}}Gb}{c{{Cb{h}}}Gb}{c{{Cb{Bd}}}Gb}{c{{Cb{Dh}}}Gb}{c{{Cb{Dj}}}Gb}{c{{Cb{Bh}}}Gb}{c{{Cb{Dn}}}Gb}{c{{Cb{Bj}}}Gb}{c{{Cb{Bl}}}Gb}{c{{Cb{Bn}}}Gb}{c{{Cb{Cf}}}Gb}{c{{Cb{Ch}}}Gb}{c{{Cb{Eb}}}Gb}{c{{Cb{Ed}}}Gb}{c{{Cb{Ef}}}Gb}{c{{Cb{{Eh{eg}}}}}GbGdGd}{c{{Cb{Cj}}}Gb}{{bc}b{}}{{dc}d{}}{{fc}f{}}{{hc}h{}}{{jc}j{}}{{bc}l{}}{{dc}l{}}{{fc}l{}}{{hc}l{}}{D`l}000000000000000000000000000000000{b{{Gf{n}}}}{d{{Gf{n}}}}{f{{Gf{n}}}}{Af{{Gf{n}}}}{Ah{{Gf{n}}}}{Aj{{Gf{n}}}}{Al{{Gf{n}}}}{An{{Gf{n}}}}{Bb{{Gf{n}}}}{h{{Gf{n}}}}{Bd{{Gf{n}}}}{Dh{{Gf{n}}}}{Dj{{Gf{n}}}}{Bh{{Gf{n}}}}{Dn{{Gf{n}}}}{Bj{{Gf{n}}}}{Bl{{Gf{n}}}}{Bn{{Gf{n}}}}{E`{{Gf{n}}}}{Cf{{Gf{n}}}}{Ch{{Gf{n}}}}{j{{Gf{n}}}}{Cj{{Gf{n}}}}{{{Cl{c}}}{{Gf{n}}}{}}{ce{}{{Gj{Gh}}}}000000000000000000000000000{{bc}l{GlGn}}{{dc}l{GlGn}}{{fc}l{GlGn}}{{Afc}l{GlGn}}{{Ahc}l{GlGn}}{{Ajc}l{GlGn}}{{Alc}l{GlGn}}{{Anc}l{GlGn}}{{Bbc}l{GlGn}}{{hc}l{GlGn}}{{Bdc}l{GlGn}}{{Dhc}l{GlGn}}{{Djc}l{GlGn}}{{Bhc}l{GlGn}}{{Dnc}l{GlGn}}{{Bjc}l{GlGn}}{{Blc}l{GlGn}}{{Bnc}l{GlGn}}{{E`c}l{GlGn}}{{Cfc}l{GlGn}}{{Chc}l{GlGn}}{{Ebc}l{GlGn}}{{Edc}l{GlGn}}{{Efc}l{GlGn}}{{{Eh{ce}}g}lH`H`{GlGn}}{{jc}l{GlGn}}{{Cjc}l{GlGn}}{{{Cl{c}}e}l{}{GlGn}}{{bb}Hb}{{dd}Hb}{{ff}Hb}{{AbAb}Hb}{{AdAd}Hb}{{AfAf}Hb}{{AhAh}Hb}{{AjAj}Hb}{{AlAl}Hb}{{AnAn}Hb}{{BbBb}Hb}{{hh}Hb}{{BdBd}Hb}{{DhDh}Hb}{{BfBf}Hb}{{DjDj}Hb}{{BhBh}Hb}{{DlDl}Hb}{{DnDn}Hb}{{BjBj}Hb}{{BlBl}Hb}{{BnBn}Hb}{{E`E`}Hb}{{CfCf}Hb}{{ChCh}Hb}{{EbEb}Hb}{{EdEd}Hb}{{EfEf}Hb}{{{Eh{ce}}{Eh{ce}}}HbHdHd}{{jj}Hb}{{EjEj}Hb}{{CjCj}Hb}{{{Cl{c}}{Cl{c}}}HbHd}{{{Cl{c}}}cCn}{hd}{{bHf}Hh}0{{dHf}Hh}0{{fHf}Hh}0{{AbHf}Hh}{{AdHf}Hh}{{AfHf}Hh}{{AhHf}Hh}{{AjHf}Hh}{{AlHf}Hh}{{AnHf}Hh}{{BbHf}Hh}{{hHf}Hh}0{{BdHf}Hh}{{DhHf}Hh}0{{BfHf}Hh}{{DjHf}Hh}{{BhHf}Hh}{{DlHf}Hh}{{DnHf}Hh}{{BjHf}Hh}0{{BlHf}Hh}0{{BnHf}Hh}0{{E`Hf}Hh}{{CfHf}Hh}0{{ChHf}Hh}{{EbHf}Hh}{{EdHf}Hh}{{EfHf}Hh}{{{Eh{ce}}Hf}HhHjHj}{{jHf}Hh}0{{EjHf}Hh}{{CjHf}Hh}{{{Cl{c}}Hf}HhHj}{{HlHf}Hh}{{bD`}{{Db{b}}}}{{dD`}{{Db{d}}}}{{fD`}{{Db{f}}}}{{hD`}{{Db{h}}}}{Fnb}{cc{}}0{Hnd}{Fnf}2222{{{B`{n}}}Af}{I`Af}4{IbAh}{{{B`{n}}}Ah}6{{{B`{n}}}Aj}{IbAj}{AnAl}99{AnBb}::{Hnh};{I`Bd}{{{B`{n}}}Bd}{IdDh}>{hDh}???{{{B`{n}}}Bh}{{{B`{n}}}Dl}{cc{}}0{{{B`{n}}}Dn}{{{B`{n}}}Bj}2{{{B`{n}}}Bl}33{{{B`{n}}}Bn}4{{{B`{n}}}Cf}5{{{B`{n}}}Ch}66666{Fdj}{Fnj}{nj}{Hnj}{Ifj};;;;;{{{B`{n}}}j}{{{B`{n}}}d}{{{A`{n}}{A`{n}}}Bl}{c{{Cb{Ane}}}{{Ih{{A`{n}}}}}{}}{c{{Cb{Bbe}}}{{Ih{{A`{n}}}}}{}}{c{{Cb{Dne}}}{{Ih{{A`{n}}}}}{}}5{Ij{{Cb{Bjc}}}{}}{{ce}{{Eh{ce}}}{}{}}{{bc}lIl}{{dc}lIl}{{fc}lIl}{{Afc}lIl}{{Ahc}lIl}{{Ajc}lIl}{{Alc}lIl}{{Anc}lIl}{{Bbc}lIl}{{hc}lIl}{{Bdc}lIl}{{Dhc}lIl}{DnFl}{{Blc}lIl}{{Bnc}lIl}{{E`c}lIl}{{Cfc}lIl}{CfFl}{{Chc}lIl}{{Ebc}lIl}{{Edc}lIl}{EfFl}{{Efc}lIl}{{jc}lIl}{{Ejc}lIl}{{Cjc}lIl}`{DhId}{{}D`}000000000000000000000000000000000{ce{}{}}000000000000000000000000000000000{Bb{{Gf{An}}}}{{{Eh{ci}}}{{Eh{ce}}}{}{}{{In{e}}}{{In{g}}}}{{{Cl{c}}}{{Jb{J`}}}Cn}0{BlBj}{{{Cl{c}}}cCn}{EfEd}{hd}{{{Cl{c}}}D`Cn}99999999999999999{{bc}b{}}{{dc}d{}}{{fc}f{}}{{hc}h{}}{{jc}j{}}{{bc}l{}}{{dc}l{}}{{fc}l{}}{{hc}l{}}{D`Bb}{IdDh}{{FlJd}Cj}{{{Gf{c}}}{{Cb{{Cl{c}}Hl}}}Cn}{{}{{Jb{Ab}}}}{{}{{Jb{Ad}}}}{{}{{Jb{An}}}}{{}{{Jb{Bf}}}}{c{{Cl{c}}}Cn}{D`{{Gf{Ad}}}}``{{}j}{E`Bn}{Bb{{`{{Jh{}{{Jf{An}}}}}}}}000{Bb{{`{{Jj{}{{Jf{An}}}}}}}}0{Eb{{Db{Fd}}}}{Ed{{Db{Fd}}}}{{bb}{{Db{El}}}}{{dd}{{Db{El}}}}{{ff}{{Db{El}}}}{{AlAl}{{Db{El}}}}{{AnAn}{{Db{El}}}}{{BbBb}{{Db{El}}}}{{hh}{{Db{El}}}}{{DhDh}{{Db{El}}}}{{CfCf}{{Db{El}}}}{{ChCh}{{Db{El}}}}{{EbEb}{{Db{El}}}}{{EdEd}{{Db{El}}}}{{jj}{{Db{El}}}}{{EjEj}{{Db{El}}}}{{CjCj}{{Db{El}}}}`{dFd}{EfFl}``{{{Cl{c}}c}lCn}{AnAd}`0`{{jc}j{}}`{Ejb}{{jj}j}00{{DhDh}{{Db{Dh}}}}`{BnBl}{{BnFl}Bl}{EfBd}{dh}{Dhh}{Efh}{h{{B`{d}}}}0{{bc}CbJl}{{dc}CbJl}{{fc}CbJl}{{Afc}CbJl}{{Ahc}CbJl}{{Ajc}CbJl}{{Alc}CbJl}{{Anc}CbJl}{{Bbc}CbJl}{{hc}CbJl}{{Bdc}CbJl}{{Dhc}CbJl}{{Djc}CbJl}{{Bhc}CbJl}{{Dnc}CbJl}{{Bjc}CbJl}{{Blc}CbJl}{{Bnc}CbJl}{{Cfc}CbJl}{{Chc}CbJl}{{Ebc}CbJl}{{Edc}CbJl}{{Efc}CbJl}{{{Eh{ce}}g}CbJnJnJl}{{Cjc}CbJl}{Edl}{{EbFd}l}{{EdK`}l}{bD`}{dD`}{fD`}{AfD`}{AhD`}{AjD`}{AlD`}{AnD`}{BbD`}{hD`}{BdD`}{DhD`}{DjD`}{BhD`}{DnD`}{BjD`}{BlD`}{BnD`}{E`D`}{CfD`}{ChD`}{EbD`}{EdD`}{EfD`}{{{Eh{ce}}}D`H`H`}{jD`}{CjD`}{{{Cl{c}}}D`{}}{{{A`{{B`{n}}}}}{{A`{Ad}}}}0{{{A`{Ad}}}{{A`{{B`{n}}}}}}0{Bb{{`{{Jj{}{{Jf{An}}}}}}}}0{An{{G`{AdAfAh}}}}0{{bb}{{Db{D`}}}}{{dd}{{Db{D`}}}}{{ff}{{Db{D`}}}}{{hh}{{Db{D`}}}}{{bb}b}{{dd}d}{{ff}f}{{hh}h}{{jj}j}{{bb}l}{{dd}l}{{ff}l}{{hh}l}{j{{B`{n}}}}{d{{B`{n}}}}{f{{B`{n}}}}{{c{A`{n}}}{{Gf{n}}}{}}0000000000000000000000000003{ce{}{}}00000000000000000000000000000000{cKb{}}000000000{{{Cl{c}}}{{Gf{c}}}Cn}{c{{Cb{e}}}{}{}}{D`{{Cb{bc}}}{}}11111{{{A`{n}}}{{Cb{Afc}}}{}}2{{{A`{n}}}{{Cb{Ahc}}}{}}{{{A`{n}}}{{Cb{Ajc}}}{}}44{{{A`{n}}}{{Cb{Alc}}}{}}{{{Gf{n}}}{{Cb{Alc}}}{}}666{{{A`{n}}}{{Cb{Bdc}}}{}}77777777777777777777777777777777777777777777777777777777{cKd{}}000000000000000000000000000000000{{}Kf}00000000000000000000000000{{be}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{de}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{fe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Afe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ahe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Aje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ale}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ane}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bbe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{he}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bde}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Dhe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Dje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bhe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Dne}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Ble}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Bne}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{E`e}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Cfe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Che}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{je}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Cje}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{{Cl{c}}g}e{}{}{{Kj{{A`{n}}}{{Kh{e}}}}}}{AnAh}0{{jj}j}0{{}j}`````{ce{}{}}0{{{Kl{c}}}{{Kl{c}}}Cn}{{ce}l{}{}}{c{{Cb{{Kl{e}}En}}}F`Fb}{{{A`{n}}}{{Cb{cEn}}}{}}{{Fd{A`{n}}}{{Cb{cEn}}}{}}{{Fdc}{{Cb{eEn}}}F`{}}{D`c{}}0{D`l}{{{Kl{c}}e}lH`{GlGn}}{{{Kl{c}}}D`H`}{{{Kl{c}}Hf}HhHj}{cc{}}{{}D`}=3{{c{A`{n}}}{{Gf{n}}}{}}>{c{{Cb{e}}}{}{}}0{cKd{}}```{KnL`}0{{{A`{n}}}Kn}{{{A`{n}}}Fl}{{{A`{{A`{n}}}}}Fl}1{{{B`{n}}{A`{n}}}Fl}{ce{}{}}0{KnKn}{{ce}l{}{}}{{KnKn}El}{c{{Cb{KnEn}}}F`}{{{A`{n}}}{{Cb{cEn}}}{}}{{Fd{A`{n}}}{{Cb{cEn}}}{}}{{Fdc}{{Cb{eEn}}}F`{}}{{}Kn}{D`c{}}{Knc{}}01{c{{Cb{Kn}}}Gb}{D`l}{{}{{Db{D`}}}}{KnD`}{{KnKn}Hb}{{KnHf}Hh}{{{B`{n}}}Kn}{L`Kn}1{cc{}}{{Knc}lIl}{{}D`}{ce{}{}}`1{{KnKn}{{Db{El}}}}{{Knc}CbJl}:{{{A`{L`}}}{{A`{Kn}}}}0{{{A`{Kn}}}{{A`{L`}}}}{{{A`{{Db{L`}}}}}{{A`{{Db{Kn}}}}}}0{{{A`{{Db{Kn}}}}}{{A`{{Db{L`}}}}}}02{Kn{{B`{n}}}}{{c{A`{n}}}{{Gf{n}}}{}}8{c{{Cb{e}}}{}{}}{{{B`{n}}}{{Cb{Knc}}}{}}01{cKd{}}{{}Kf}{{Kne}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{{Gf{L`}}}{{Gf{Kn}}}}{{{Gf{{Db{L`}}}}}{{Gf{{Db{Kn}}}}}}{{{Gf{{Db{Kn}}}}}{{Gf{{Db{L`}}}}}}{{{Gf{Kn}}}{{Gf{L`}}}}```````{I`Lb}{IbLb}10{ce{}{}}0000000{{{A`{n}}D`D`}{{Cb{LdKb}}}}{LfLf}{I`I`}{IbIb}{LhLh}{{ce}l{}{}}000{{LhLf}{{Cb{I`Kb}}}}{{LhLfD`Fd}{{Cb{IbKb}}}}{{}I`}{{}Ib}{D`c{}}{I`c{}}1{Ibc{}}22221202{D`l}000{{}Ld}{{I`I`}Hb}{{IbIb}Hb}{{LfHf}Hh}{{I`Hf}Hh}{{IbHf}Hh}{{LhHf}Hh}{cc{}}{LjLf}{LbI`}22{LbIb}3{{LhD`}{{Cb{{Ln{Ll}}Kb}}}}{{}D`}000{ce{}{}}000{LdLh}{Lfl}{{Lh{A`{Kn}}}{{Cb{LfKb}}}}{{{A`{Lb}}}{{A`{I`}}}}0{{{A`{I`}}}{{A`{Lb}}}}{{{A`{{Db{Lb}}}}}{{A`{{Db{I`}}}}}}0{{{A`{{Db{I`}}}}}{{A`{{Db{Lb}}}}}}02{I`{{B`{n}}}}{Ib{{B`{n}}}}9999{c{{Cb{e}}}{}{}}{Af{{Cb{I`c}}}{}}{{{B`{n}}}{{Cb{I`c}}}{}}{Bd{{Cb{I`c}}}{}}2130{Aj{{Cb{Ibc}}}{}}0{Ah{{Cb{Ibc}}}{}}{{{B`{n}}}{{Cb{Ibc}}}{}}0616{{{B`{n}}}{{Cb{I`Kb}}}}{{{B`{n}}}{{Cb{IbKb}}}}8888{cKd{}}000{{{Gf{Lb}}}{{Gf{I`}}}}{{{Gf{{Db{Lb}}}}}{{Gf{{Db{I`}}}}}}{{{Gf{{Db{I`}}}}}{{Gf{{Db{Lb}}}}}}{{{Gf{I`}}}{{Gf{Lb}}}}{{LhI`D`FdKnIb}Hb}````````{ce{}{}}000000000{M`M`}{MbMb}{MdMd}{MfMf}{MhMh}{{ce}l{}{}}0000{{M`M`}El}{{MbMb}El}{{MdMd}El}{{MfMf}El}{{MhMh}El}{c{{Cb{M`En}}}F`}{c{{Cb{MbEn}}}F`}{c{{Cb{MdEn}}}F`}{c{{Cb{MfEn}}}F`}{c{{Cb{MhEn}}}F`}{{{A`{n}}}{{Cb{cEn}}}{}}0000{{Fd{A`{n}}}{{Cb{cEn}}}{}}0000{{Fdc}{{Cb{eEn}}}F`{}}0000{{}Mb}{{}Mf}{D`c{}}000000000{c{{Cb{M`}}}Gb}{c{{Cb{Mb}}}Gb}{c{{Cb{Md}}}Gb}{c{{Cb{Mf}}}Gb}{c{{Cb{Mh}}}Gb}{D`l}0000{Mb{{Gf{n}}}}{Mf{{Gf{n}}}}{{M`c}l{GlGn}}{{Mbc}l{GlGn}}{{Mdc}l{GlGn}}{{Mfc}l{GlGn}}{{Mhc}l{GlGn}}{{M`M`}Hb}{{MbMb}Hb}{{MdMd}Hb}{{MfMf}Hb}{{MhMh}Hb}{{M`Hf}Hh}{{MbHf}Hh}{{MdHf}Hh}{{MfHf}Hh}{{MhHf}Hh}{cc{}}0000{M`Fl}{{M`c}lIl}{{Mbc}lIl}{MdFl}{{Mdc}lIl}{{Mfc}lIl}{{Mhc}lIl}{{}D`}0000{ce{}{}}0000``{M`Fd}{MdFd}{MhFd}{{M`M`}{{Db{El}}}}{{MbMb}{{Db{El}}}}{{MdMd}{{Db{El}}}}{{MfMf}{{Db{El}}}}{{MhMh}{{Db{El}}}}{Mhd}{{M`c}CbJl}{{Mbc}CbJl}{{Mdc}CbJl}{{Mfc}CbJl}{{Mhc}CbJl}{{M`Fd}l}{M`D`}{MbD`}{MdD`}{MfD`}{MhD`}{{c{A`{n}}}{{Gf{n}}}{}}0000{ce{}{}}0000{c{{Cb{e}}}{}{}}000000000{cKd{}}0000{{}Kf}0000{{Mbe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}{{Mfe}c{}{{Kj{{A`{n}}}{{Kh{c}}}}}}``````","c":[],"p":[[5,"SBucket",0],[5,"PieceIndex",0],[5,"PieceOffset",0],[5,"SegmentIndex",0],[5,"U256",0],[1,"unit"],[1,"u8"],[1,"slice"],[5,"RawRecord",0],[5,"Record",0],[5,"RecordCommitment",0],[5,"RecordWitness",0],[5,"ChunkWitness",0],[5,"Piece",0],[5,"PieceArray",0],[1,"array"],[5,"FlatPieces",0],[5,"SegmentCommitment",0],[5,"RecordedHistorySegment",0],[5,"Randomness",0],[5,"PotKey",0],[5,"PotSeed",0],[5,"PotOutput",0],[6,"Error",1800],[6,"Result",1801],[10,"FromByteSlice",1800],[5,"PublicKey",0],[5,"RewardSignature",0],[5,"SectorId",0],[5,"NonEmptyVec",0],[10,"Clone",1802],[1,"usize"],[6,"Option",1803],[10,"WrappingSub",1804],[10,"Ord",1805],[5,"HistorySize",0],[5,"ArchivedHistorySegment",0],[5,"PosSeed",0],[5,"PosProof",0],[5,"PotCheckpoints",0],[6,"ArchivedBlockProgress",0],[5,"LastArchivedBlock",0],[6,"SegmentHeader",0],[5,"Solution",0],[5,"SectorSlotChallenge",0],[6,"Ordering",1805],[5,"Error",1806],[10,"Input",1807],[10,"Decode",1807],[1,"u32"],[20,"MaybeUninit",1808],[5,"DecodeFinished",1809],[8,"SlotNumber",0],[8,"Blake3Hash",0],[1,"u16"],[1,"tuple"],[10,"Deserializer",1810],[10,"Deserialize",1810],[5,"Vec",1811],[1,"char"],[10,"FromIterator",1812],[10,"Output",1807],[10,"Sized",1813],[10,"Encode",1807],[1,"bool"],[10,"PartialEq",1805],[5,"Formatter",1814],[8,"Result",1814],[10,"Debug",1814],[6,"NonEmptyVecErr",0],[1,"u64"],[5,"Commitment",1507],[5,"Witness",1507],[5,"NonZeroU64",1815],[1,"u128"],[10,"AsRef",1816],[1,"str"],[10,"Hasher",1817],[10,"Into",1816],[10,"Iterator",1818],[5,"Box",1819],[8,"SectorIndex",0],[17,"Item"],[10,"IndexedParallelIterator",1820],[10,"ExactSizeIterator",1821],[10,"Serializer",1822],[10,"Serialize",1822],[8,"BlockNumber",0],[5,"String",1823],[5,"TypeId",1824],[5,"Type",1825],[17,"Output"],[10,"FnOnce",1826],[5,"Blake3Checksummed",1419],[5,"Scalar",1443],[5,"FsFr",1827],[5,"FsG1",1828],[5,"FsKZGSettings",1829],[5,"Polynomial",1507],[5,"Kzg",1507],[5,"FsPoly",1830],[5,"FsFFTSettings",1831],[5,"Arc",1832],[6,"BlockObject",1626],[5,"BlockObjectMapping",1626],[6,"PieceObject",1626],[5,"PieceObjectMapping",1626],[6,"GlobalObject",1626],[15,"V0",1415],[15,"V0",1794],[15,"V0",1796],[15,"V0",1798]],"b":[[112,"impl-AsMut%3C%5Bu8;+Piece::SIZE%5D%3E-for-PieceArray"],[113,"impl-AsMut%3C%5Bu8%5D%3E-for-PieceArray"],[149,"impl-AsRef%3C%5Bu8;+Piece::SIZE%5D%3E-for-PieceArray"],[150,"impl-AsRef%3C%5Bu8%5D%3E-for-PieceArray"],[783,"impl-Display-for-SBucket"],[784,"impl-Debug-for-SBucket"],[785,"impl-Debug-for-PieceIndex"],[786,"impl-Display-for-PieceIndex"],[787,"impl-Display-for-PieceOffset"],[788,"impl-Debug-for-PieceOffset"],[797,"impl-Debug-for-SegmentIndex"],[798,"impl-Display-for-SegmentIndex"],[800,"impl-Display-for-HistorySize"],[801,"impl-Debug-for-HistorySize"],[807,"impl-Debug-for-PotKey"],[808,"impl-Display-for-PotKey"],[809,"impl-Debug-for-PotSeed"],[810,"impl-Display-for-PotSeed"],[811,"impl-Display-for-PotOutput"],[812,"impl-Debug-for-PotOutput"],[814,"impl-Debug-for-PublicKey"],[815,"impl-Display-for-PublicKey"],[821,"impl-Debug-for-U256"],[822,"impl-Display-for-U256"],[840,"impl-From%3C%5Bu8;+RecordCommitment::SIZE%5D%3E-for-RecordCommitment"],[841,"impl-From%3CCommitment%3E-for-RecordCommitment"],[843,"impl-From%3CWitness%3E-for-RecordWitness"],[844,"impl-From%3C%5Bu8;+RecordWitness::SIZE%5D%3E-for-RecordWitness"],[846,"impl-From%3C%5Bu8;+ChunkWitness::SIZE%5D%3E-for-ChunkWitness"],[847,"impl-From%3CWitness%3E-for-ChunkWitness"],[856,"impl-From%3CCommitment%3E-for-SegmentCommitment"],[857,"impl-From%3C%5Bu8;+SegmentCommitment::SIZE%5D%3E-for-SegmentCommitment"],[858,"impl-From%3CNonZeroU64%3E-for-HistorySize"],[860,"impl-From%3CSegmentIndex%3E-for-HistorySize"],[884,"impl-From%3Cu32%3E-for-U256"],[885,"impl-From%3Cu16%3E-for-U256"],[886,"impl-From%3Cu8%3E-for-U256"],[887,"impl-From%3Cu64%3E-for-U256"],[888,"impl-From%3Cu128%3E-for-U256"],[919,"impl-Hash-for-PublicKey"],[920,"impl-PublicKey"],[924,"impl-SegmentHeader"],[925,"impl-Hash-for-SegmentHeader"],[1263,"impl-TryFrom%3C%26%5Bu8%5D%3E-for-Piece"],[1264,"impl-TryFrom%3CVec%3Cu8%3E%3E-for-Piece"],[1473,"impl-From%3C%5Bu8;+Self::SAFE_BYTES%5D%3E-for-Scalar"],[1474,"impl-From%3CFsFr%3E-for-Scalar"],[1475,"impl-From%3C%26%5Bu8;+Self::SAFE_BYTES%5D%3E-for-Scalar"],[1497,"impl-TryFrom%3C%26%5Bu8;+Self::FULL_BYTES%5D%3E-for-Scalar"],[1498,"impl-TryFrom%3C%5Bu8;+Self::FULL_BYTES%5D%3E-for-Scalar"],[1596,"impl-TryFrom%3C%26RecordCommitment%3E-for-Commitment"],[1597,"impl-TryFrom%3C%5Bu8;+Self::SIZE%5D%3E-for-Commitment"],[1598,"impl-TryFrom%3C%26SegmentCommitment%3E-for-Commitment"],[1599,"impl-TryFrom%3CRecordCommitment%3E-for-Commitment"],[1600,"impl-TryFrom%3C%26%5Bu8;+Self::SIZE%5D%3E-for-Commitment"],[1602,"impl-TryFrom%3CSegmentCommitment%3E-for-Commitment"],[1603,"impl-TryFrom%3CChunkWitness%3E-for-Witness"],[1604,"impl-TryFrom%3C%26ChunkWitness%3E-for-Witness"],[1605,"impl-TryFrom%3C%26RecordWitness%3E-for-Witness"],[1606,"impl-TryFrom%3C%26%5Bu8;+Self::SIZE%5D%3E-for-Witness"],[1607,"impl-TryFrom%3C%5Bu8;+Self::SIZE%5D%3E-for-Witness"],[1609,"impl-TryFrom%3CRecordWitness%3E-for-Witness"],[1723,"impl-BlockObject"],[1724,"impl-Hash-for-BlockObject"],[1726,"impl-PieceObject"],[1727,"impl-Hash-for-PieceObject"]]}],\ ["subspace_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":"FSEFENNNNNNNNNNNNNNNNNNNNNNNNNNNENNCNNNCNCNNNCNNNNNNCNNNNNNNNNNCNNIKKMMMMMMMMMMMFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHPPGPPPPPPPPPPPPPPPPPPPPPPPPPPPPEPPPPPPPPPPPPTPPPPPTPPPGPPGGGFGGGFFGGPPPPPPPPNONNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNOOOCONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONONNNONNNNCNOCNNNNOONNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOFPPPGPPFFNNNNNNNNNNNNNNNNNNNNNNNNNOOONNNNNNNNNNNNNNNNNNNOONOCOOOONONNNNNNNNNNNNNNNNNNNNNNNOOFNNNNNNNNNNNNNNNNPPFGPFPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOFNNNNNNNNNNNNNNNNNNFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNFFHNNNNNNNHNNNNNNNCNNNNNNNNNHCNNHCHCHNHNNNNNNNNNNNNFNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNNPPPPPGNNNNNNNNNNHNNNNNN","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","FailedToDecodeSectorMetadata","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","WrongChain","Wrote","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_plot_audited","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","AuditEvent","FailedToCreateThreadPool","FailedToGetFarmerInfo","FailedToSubscribeSlotInfo","FarmingError","Io","LowLevelProving","PlotAudit","PlotAuditOptions","audit","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","drop","drop","drop","drop","duration","erasure_coding","farm_id","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","init","init","init","init","into","into","into","into","kzg","maybe_sector_being_modified","new","public_key","rayon_files","reward_address","sectors_metadata","sectors_number","slot_info","source","table_generator","to_owned","to_owned","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","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","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","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"],[489,"subspace_farmer::single_disk_farm::BackgroundTaskError"],[490,"subspace_farmer::single_disk_farm::PlottingError"],[494,"subspace_farmer::single_disk_farm::SectorExpirationDetails"],[495,"subspace_farmer::single_disk_farm::SectorPlottingDetails"],[501,"subspace_farmer::single_disk_farm::SingleDiskFarmError"],[516,"subspace_farmer::single_disk_farm::SingleDiskFarmInfo"],[521,"subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"],[548,"subspace_farmer::single_disk_farm::SingleDiskFarmSummary"],[553,"subspace_farmer::single_disk_farm::farming"],[643,"subspace_farmer::single_disk_farm::farming::FarmingError"],[645,"subspace_farmer::single_disk_farm::farming::rayon_files"],[662,"subspace_farmer::single_disk_farm::piece_cache"],[724,"subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"],[726,"subspace_farmer::single_disk_farm::piece_reader"],[745,"subspace_farmer::thread_pool_manager"],[799,"subspace_farmer::utils"],[850,"subspace_farmer::utils::farmer_piece_getter"],[866,"subspace_farmer::utils::piece_validator"],[885,"subspace_farmer::utils::readers_and_pieces"],[906,"subspace_farmer::utils::ss58"],[929,"subspace_core_primitives::segments"],[930,"core::future::future"],[931,"alloc::boxed"],[932,"core::pin"],[933,"core::result"],[934,"std::path"],[935,"core::convert"],[936,"core::fmt"],[937,"core::fmt"],[938,"core::option"],[939,"subspace_core_primitives::pieces"],[940,"schnorrkel::keys"],[941,"schnorrkel::keys"],[942,"schnorrkel::sign"],[943,"subspace_rpc_primitives"],[944,"subspace_rpc_primitives"],[945,"core::fmt"],[946,"subspace_core_primitives::pieces"],[947,"core::ops::function"],[948,"alloc::sync"],[949,"event_listener_primitives::handler_id"],[950,"libp2p_kad::record"],[951,"subspace_farmer_components::plotting"],[952,"core::error"],[953,"core::cmp"],[954,"std::path"],[955,"parity_scale_codec::codec"],[956,"serde::de"],[957,"parity_scale_codec::codec"],[958,"std::io::error"],[959,"subspace_farmer_components::plotting"],[960,"core::hash"],[961,"std::io::error"],[962,"core::marker"],[963,"subspace_farmer_components::plotting"],[964,"subspace_farmer_components::sector"],[965,"anyhow"],[966,"serde::ser"],[967,"alloc::string"],[968,"subspace_core_primitives"],[969,"subspace_farmer_components::proving"],[970,"subspace_proof_of_space"],[971,"rayon_core"],[972,"subspace_core_primitives::pieces"],[973,"core::ops::function"],[974,"tokio::runtime::task::join"],[975,"core::num::error"],[976,"core::task::wake"],[977,"core::task::poll"],[978,"rayon_core::registry"],[979,"core::ops::function"],[980,"subspace_networking::utils::piece_provider"],[981,"subspace_networking::node"],[982,"subspace_core_primitives::crypto::kzg"],[983,"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 decode sector metadata","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 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","Wrong chain (genesis hash)","Wrote sector","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 notification about audited plots","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","","Failed to create thread pool","Failed to retrieve farmer info","Failed to subscribe to slot info notifications","Errors that happen during farming","I/O error occurred","Low-level proving error","Plot auditing implementation","Plot audit options","","","","","","","","","","","","","","","","","","","","","","","","","","Defines how much time took the audit in secs","Erasure coding instance","ID of the farm","","","","","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).","Kzg instance","Optional sector that is currently being modified (for …","Create new instance","Public key of the farm","","Reward address to use for solutions","Metadata of all sectors plotted so far","Number of sectors for this audit","Slot info for the audit","","Proof of space table generator","","","","","","","","","","","","","","","","","","","","","","","","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 …","","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,49,62,0,65,64,64,63,63,49,48,48,48,48,53,50,49,63,64,63,64,62,62,63,64,62,64,64,64,62,63,65,0,48,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,48,47,63,64,46,48,63,48,46,74,89,74,58,62,47,46,53,63,64,65,48,49,50,89,74,58,62,47,46,53,63,64,65,48,49,50,74,47,46,48,49,50,47,46,48,49,50,47,58,47,48,49,50,48,49,50,48,49,50,48,49,50,89,74,58,62,47,46,53,63,64,65,48,49,50,89,74,58,62,47,46,53,63,64,65,48,49,50,47,46,74,74,89,74,58,58,62,47,46,53,63,64,65,48,49,50,48,49,50,47,47,47,47,74,74,74,0,74,62,62,47,47,46,53,63,63,64,64,65,65,48,49,50,89,74,58,62,62,62,47,47,46,53,63,63,63,64,65,65,65,65,48,49,50,46,47,58,46,58,89,74,58,62,47,46,53,63,64,65,48,49,50,89,74,58,62,47,46,53,63,64,65,48,49,50,74,46,74,58,47,46,74,58,58,58,47,0,58,74,0,58,46,58,58,74,74,46,58,74,58,58,47,46,48,49,50,62,63,65,46,48,49,50,47,46,48,49,50,62,47,63,64,65,58,89,74,58,62,47,46,53,63,64,65,48,49,50,89,74,58,62,47,46,53,63,64,65,48,49,50,46,89,74,58,62,47,46,53,63,64,65,48,49,50,89,74,58,62,47,46,53,63,64,65,48,49,50,89,74,58,62,47,46,53,63,64,65,48,49,50,58,129,130,131,132,133,134,135,136,136,135,135,136,137,138,137,139,140,139,140,141,141,137,137,141,138,139,140,142,142,142,142,142,143,144,145,146,147,148,149,143,144,145,150,146,151,147,152,148,153,154,149,155,155,144,145,153,144,145,153,156,157,158,158,156,0,70,70,70,0,70,70,0,0,90,90,97,70,91,90,97,70,91,97,91,97,91,90,97,70,91,90,97,70,91,90,97,70,91,97,91,97,97,70,70,91,90,97,70,70,70,70,91,90,97,70,91,90,97,70,91,91,91,90,91,0,91,91,97,91,70,91,97,91,70,90,97,70,91,90,97,70,91,90,97,70,91,90,97,70,91,90,97,70,91,159,160,0,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,99,69,69,0,0,69,0,69,69,69,100,41,69,100,41,100,41,100,41,69,100,41,69,100,41,69,100,41,69,69,100,100,41,69,69,100,41,69,100,41,69,100,41,69,100,41,69,100,69,100,41,69,100,41,69,100,41,69,100,41,69,100,41,161,161,0,80,80,80,80,80,80,80,80,80,80,80,80,80,80,80,80,80,80,0,0,0,104,103,102,104,103,102,102,102,104,103,103,102,104,103,102,104,103,103,102,104,103,102,104,103,102,102,104,103,102,104,103,102,102,104,104,102,104,103,102,104,103,102,104,103,102,104,103,102,104,103,102,0,0,0,109,107,109,107,107,107,107,0,109,107,109,107,109,109,107,0,107,109,107,109,107,109,107,109,109,0,0,107,109,0,0,0,0,0,107,0,107,109,107,109,107,109,109,107,109,107,109,107,0,117,117,117,117,117,117,117,117,117,117,117,117,117,117,117,0,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,123,0,121,121,121,121,121,121,121,121,121,121,121,121,121,121,121,121,121,121,121,121,128,128,128,128,128,0,128,128,128,128,128,128,128,128,128,128,0,128,128,128,128,128,128],"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}{ElEl}{F`F`}{FbFb}{FdFd}{{ce}n{}{}}0000{{EnEn}Ff}{FhFj}{{ce}Ff{}{}}{c{{A`{F`Fl}}}Fn}{c{{A`{FbFl}}}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`{En}}}Gb}{c{{A`{El}}}Gb}``{Afn}00{Gdn}1111111111{{F`c}n{GfGh}}{{Fbc}n{GfGh}}{{Fdc}n{GfGh}}{{EnEn}Gj}{{ce}Gj{}{}}00`````{{GlAl}An}0{{EnAl}An}0{{ElAl}An}{{FjAl}An}{{GnAl}An}0{{H`Al}An}0{{HbAl}An}0{{F`Al}An}{{FbAl}An}{{FdAl}An}{cc{}}00{HdGl}{HfGl}2{HhEn}333{HdGn}4{HjGn}55{HlHb}{GlHb}{{{h{Ej}}}Hb}888{El{{Hn{Ah}}}}{{Enc}nI`}{GdEn}{ElEn}{GdEl}{{}Af}000000000000{ce{}{}}000000000000`{Ab{{Ib{{Bf{El}}}}}}`{{{Id{ce}}Af}{{A`{GdGn}}}Ch{EfIfIhIj}}{{}En}{{En{Hn{Ah}}IlInB`}El}`{{Gd{Dl{Dj}}}Dn}00{{EnEn}{{Bf{Ff}}}}`{GdEb}``{GdJ`}{ElIn}{Gd{{`{{Jf{}{{Jb{{A`{JdFl}}}}}}}}}}{GdAf}``{ElIl}{Ab{{Ib{{Bn{Jh}}}}}}`{Gd{{Jj{En}}}}{Ab{{A`{nH`}}}}{{Enc}A`Jl}{{Elc}A`Jl}{F`Af}{FbAf}{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}}}{{Bn{{Dh{K`{`{{Kl{}{{Jb{{A`{{Kh{IlIl}}Kj}}}}}}}}}}}}}KnL`}77777777{LbLb}{{{Kf{c}}}{{Kf{c}}}L`}{{ce}n{}{}}0{Afc{}}0000000{Afn}000```{{LbAl}An}{{HlAl}An}0{{{Kf{c}}Al}An{L`D`}}{cc{}}0{HdHl}1{LdHl}{KjHl}3{{}Af}000{ce{}{}}000``{c{{Kd{c}}}Kn}``````{Hl{{Bf{Ej}}}}`22{cJn{}}{c{{A`{e}}}{}{}}0000000{cCf{}}00055555555```55??>:65{Ab{{Ib{Lf}}}}{{Lf{Aj{Ah}}Af}{{Ib{n}}}}033277````````777777{LhLh}{EbEb}{{ce}n{}{}}0{Afc{}}00000{Afn}00{{HjAl}An}0{{LhAl}An}0{{EbAl}An}{cc{}}{HdHj}11{{}Af}00{ce{}{}}00{Hj{{Bf{Ej}}}}11{cJn{}}0{c{{A`{e}}}{}{}}00000{cCf{}}00444444```44{J`J`}>==<{{J`Al}An}976{{J`K`Lj}{{Bf{Dd}}}}744377```777777{LlLl}{{ce}n{}{}}{Afc{}}0{Lnc{}}1111{Afn}{Lnn}11{{M`Al}An}{{LnAl}An}{{LlAl}An}{cc{}}00{LlLn}{{}Af}00{ce{}{}}00{{cMb}{{A`{LlLd}}}{{Md{Af}{{Eh{{A`{M`Ld}}}}}}}}``1{c{{A`{e}}}{}{}}00000{cCf{}}00333333``{{}{{Bn{Mf}}}}4444{MfMf}{{ce}n{}{}}{Mf{{Aj{Af}}}}{c{{A`{LlLd}}}{{Mh{}{{Jb{{Dh{MfMf}}}}}}}}{Afc{}}000{Afn}{{{Mj{c}}}n{}}1`{{MfAl}An}??==<<{c{}{}}{{{Ml{c}}Gj}{{Mj{c}}}{}}{Bb{{A`{{Bn{Mf}}Mn}}}}`{Mfn}{{{j{{Mj{c}}}}N`}{{Nb{e}}}{}{}}{g{{`{{Md{Nd}{{Eh{{Ib{n}}}}}}}}}Ih{{Nf{}{{Eh{c}}}}Ih}{{Md{Nd}{{Eh{e}}}}If}}`{{gJn}{{Ib{{`{{f{}{{Eh{{A`{cNh}}}}}}Ih}}}}}Ih{{f{}{{Eh{c}}}}}{{Nf{}{{Eh{e}}}}Ih}}`{{{Bf{Mb}}{Bf{Mb}}}{{Bn{Mf}}}}{ce{}{}}{{}{{`{{Md{Nd}{{Eh{{Ib{n}}}}}}}}}}{{MfAf}n}{c{{A`{e}}}{}{}}000{{{j{c}}N`}Nb{}}{cCf{}}05555`55{Afc{}}0{Afn}{cc{}}{{{Nj{ce}}BhNl}{{j{{h{f}}}}}{NnIh}Ch}{{}Af}:{{{O`{c}}Cle{Dl{{Od{{Bf{Ob}}}}}}}{{Nj{ce}}}{}{}}886;;`;;{{{Of{c}}}{{Of{c}}}If}{{ce}n{}{}}77653={{OhcOj{Dl{{Od{{On{dOl}}}}}}}{{Of{c}}}{}}>;;9>{{{Of{c}}DfBhDd}{{j{{h{f}}}}}Ch}?`{{ObAhJd}n}{ce{}{}}0{{ObBh}Gj}2<<;{{ObAl}An};92{{{Bn{J`}}}Ob}{Ob{{`{{Jf{}{{Jb{Bh}}}}}}}}{{ObBh}{{Bf{{`{{f{}{{Eh{{Bf{Dd}}}}}}}}}}}}{c{{A`{e}}}{}{}}0{cCf{}}77``````77{Afc{}}0{Afn}{{A`Al}An}0{cc{}}{{}Af}<{Bb{{A`{IlA`}}}}{cJn{}}887>>","c":[],"p":[[5,"NodeRpcClient",0],[5,"SegmentIndex",929],[10,"Future",930],[5,"Box",931],[5,"Pin",932],[5,"Identity",0],[1,"unit"],[6,"Result",933],[5,"Path",934],[10,"AsRef",935],[1,"usize"],[1,"u8"],[1,"slice"],[5,"Formatter",936],[8,"Result",936],[1,"u64"],[1,"str"],[6,"Error",937],[6,"Option",938],[5,"PieceIndex",939],[5,"PublicKey",940],[5,"SecretKey",940],[5,"Vec",941],[5,"Signature",942],[5,"RewardSignatureResponse",943],[5,"SolutionResponse",943],[5,"TypeId",944],[10,"NodeClient",66],[10,"NodeClientExt",66],[5,"PieceCache",80],[5,"CacheWorker",80],[10,"Debug",936],[5,"Key",945],[5,"Piece",939],[5,"PeerId",946],[1,"tuple"],[10,"Fn",947],[5,"Arc",948],[5,"HandlerId",949],[5,"ProviderRecord",945],[5,"DiskPieceCache",662],[5,"Receiver",950],[10,"PieceGetter",951],[17,"Output"],[10,"Error",952],[6,"SingleDiskFarmInfo",120],[6,"SingleDiskFarmId",120],[6,"SectorPlottingDetails",120],[6,"SectorExpirationDetails",120],[6,"SectorUpdate",120],[6,"Ordering",953],[5,"PathBuf",934],[6,"SingleDiskFarmSummary",120],[5,"Error",954],[10,"Input",955],[1,"u32"],[10,"Deserializer",956],[5,"SingleDiskFarm",120],[10,"Output",955],[10,"Sized",957],[1,"bool"],[6,"PlottingError",120],[6,"SingleDiskFarmError",120],[6,"SingleDiskFarmScrubError",120],[6,"BackgroundTaskError",120],[5,"Error",958],[6,"PlottingError",951],[5,"Ulid",959],[6,"DiskPieceCacheError",662],[6,"FarmingError",553],[1,"array"],[10,"Hasher",960],[8,"Result",958],[5,"SingleDiskFarmOptions",120],[10,"Clone",961],[10,"Send",957],[10,"Sync",957],[5,"PublicKey",962],[1,"u16"],[5,"PieceReader",726],[17,"Item"],[5,"PlottedSector",951],[10,"Iterator",963],[5,"SectorMetadataChecksummed",964],[8,"Result",965],[10,"Serializer",966],[5,"String",967],[8,"SectorIndex",962],[5,"SingleDiskFarmInfoLock",120],[5,"PlotAudit",553],[5,"PlotAuditOptions",553],[5,"Solution",962],[6,"ProvingError",968],[10,"ProvableSolutions",968],[10,"ReadAtSync",969],[10,"Table",970],[5,"AuditEvent",553],[5,"ThreadPoolBuildError",971],[5,"RayonFiles",645],[5,"Offset",662],[5,"PieceOffset",939],[5,"PlottingThreadPoolManager",745],[5,"PlottingThreadPoolsGuard",745],[5,"PlottingThreadPoolPair",745],[5,"NonZeroUsize",972],[10,"FnMut",947],[5,"CpuCoreSet",799],[10,"ExactSizeIterator",973],[5,"AsyncJoinOnDrop",799],[5,"JoinHandle",974],[5,"ParseIntError",975],[5,"Context",976],[6,"Poll",977],[5,"ThreadBuilder",978],[10,"FnOnce",947],[5,"Canceled",950],[5,"FarmerPieceGetter",850],[6,"PieceGetterRetryPolicy",951],[10,"PieceValidator",979],[5,"PieceProvider",979],[5,"ReadersAndPieces",885],[8,"Mutex",980],[5,"SegmentCommitmentPieceValidator",866],[5,"Node",981],[5,"Kzg",982],[5,"SegmentCommitment",929],[5,"LruCache",983],[6,"Ss58ParsingError",906],[15,"BackgroundTaskPanicked",489],[15,"FailedToGetFarmerInfo",490],[15,"FailedToGetSegmentHeader",490],[15,"FailedToSubscribeArchivedSegments",490],[15,"MissingArchivedSegmentHeader",490],[15,"Determined",494],[15,"Starting",495],[15,"Finished",495],[15,"FarmTooLarge",501],[15,"InsufficientAllocatedSpace",501],[15,"WrongChain",501],[15,"IdentityMismatch",501],[15,"InvalidPiecesInSector",501],[15,"V0",516],[15,"FailedToDetermineFileSize",521],[15,"FailedToReadBytes",521],[15,"FailedToWriteBytes",521],[15,"FarmInfoCantBeOpened",521],[15,"IdentityCantBeOpened",521],[15,"MetadataCantBeOpened",521],[15,"CacheCantBeOpened",521],[15,"FarmInfoFileDoesNotExist",521],[15,"IdentityFileDoesNotExist",521],[15,"MetadataFileDoesNotExist",521],[15,"MetadataFileTooSmall",521],[15,"CacheFileDoesNotExist",521],[15,"PublicKeyMismatch",521],[15,"Found",548],[15,"NotFound",548],[15,"Error",548],[15,"FailedToSubscribeSlotInfo",643],[15,"FailedToGetFarmerInfo",643],[15,"OffsetOutsideOfRange",724]],"b":[[306,"impl-Debug-for-PlottingError"],[307,"impl-Display-for-PlottingError"],[308,"impl-Debug-for-SingleDiskFarmId"],[309,"impl-Display-for-SingleDiskFarmId"],[312,"impl-Display-for-SingleDiskFarmError"],[313,"impl-Debug-for-SingleDiskFarmError"],[314,"impl-Display-for-SingleDiskFarmScrubError"],[315,"impl-Debug-for-SingleDiskFarmScrubError"],[316,"impl-Display-for-BackgroundTaskError"],[317,"impl-Debug-for-BackgroundTaskError"],[324,"impl-From%3CError%3E-for-PlottingError"],[325,"impl-From%3CPlottingError%3E-for-PlottingError"],[331,"impl-From%3CError%3E-for-SingleDiskFarmError"],[333,"impl-From%3CDiskPieceCacheError%3E-for-SingleDiskFarmError"],[336,"impl-From%3CFarmingError%3E-for-BackgroundTaskError"],[337,"impl-From%3CPlottingError%3E-for-BackgroundTaskError"],[338,"impl-From%3CBox%3Cdyn+Error+%2B+Send+%2B+Sync%3E%3E-for-BackgroundTaskError"],[591,"impl-Debug-for-FarmingError"],[592,"impl-Display-for-FarmingError"],[596,"impl-From%3CError%3E-for-FarmingError"],[598,"impl-From%3CThreadPoolBuildError%3E-for-FarmingError"],[599,"impl-From%3CProvingError%3E-for-FarmingError"],[655,"impl-ReadAtSync-for-%26RayonFiles"],[656,"impl-ReadAtSync-for-RayonFiles"],[689,"impl-Debug-for-DiskPieceCacheError"],[690,"impl-Display-for-DiskPieceCacheError"],[691,"impl-Display-for-Offset"],[692,"impl-Debug-for-Offset"],[917,"impl-Debug-for-Ss58ParsingError"],[918,"impl-Display-for-Ss58ParsingError"]]}],\ -["subspace_farmer_components",{"doc":"Components of the reference implementation of Subspace …","t":"PFFGKFKPNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNONNNNNNNNNOONNCCMMNNNNCOOCNNNNNNNNNNNNNNNNNNNNNNNNNFHHONNNNNNNNNNNOONNNNNNKKMMMMMMMPPFFFPPPPKGPPFFGPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHONNNNNNNHNONOOOONNNNNNNNNNNNMNNNNNNNNNNNNNNOOOOOOOOOOHOOOOOOOOOOOONNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOPPPPPKGPFMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOPPPPPPFGPNNNNNNONNNNNNNNNNNNNNNNNHHHHONNNNNNNNNNNNNOOOOOOOOOOOPFPPPPFGGGFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNONNOOHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOO","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","audit_plot_sync","audit_sector_sync","best_solution_distance","borrow","borrow_mut","clone","clone_into","deref","deref_mut","drop","fmt","from","init","into","sector_index","solution_candidates","to_owned","try_from","try_into","type_id","unique_saturated_into","vzip","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","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","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"],[125,"subspace_farmer_components::file_ext"],[134,"subspace_farmer_components::plotting"],[298,"subspace_farmer_components::plotting::PlottingError"],[307,"subspace_farmer_components::proving"],[357,"subspace_farmer_components::proving::ProvingError"],[362,"subspace_farmer_components::reading"],[414,"subspace_farmer_components::reading::ReadingError"],[424,"subspace_farmer_components::sector"],[603,"subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"],[605,"subspace_farmer_components::sector::SectorContentsMapFromBytesError"],[609,"subspace_farmer_components::sector::SectorContentsMapIterationError"],[611,"core::convert"],[612,"core::marker"],[613,"bitvec::slice"],[614,"bitvec::order"],[615,"byte_slice_cast"],[616,"core::result"],[617,"byte_slice_cast"],[618,"serde::de"],[619,"core::fmt"],[620,"core::fmt"],[621,"alloc::vec"],[622,"std::io::error"],[623,"core::future::future"],[624,"serde::ser"],[625,"bitvec::ptr::span"],[626,"core::any"],[627,"subspace_core_primitives"],[628,"subspace_core_primitives"],[629,"parity_scale_codec::error"],[630,"parity_scale_codec::codec"],[631,"subspace_proof_of_space"],[632,"parity_scale_codec::codec"],[633,"subspace_core_primitives::pieces"],[634,"core::pin"],[635,"core::error"],[636,"alloc::string"],[637,"std::io::error"],[638,"subspace_erasure_coding"],[639,"subspace_core_primitives"],[640,"subspace_core_primitives::pieces"],[641,"core::iter::traits::exact_size"],[642,"core::ops::deref"],[643,"core::ops::deref"],[644,"subspace_core_primitives::pieces"],[645,"rayon::iter"],[646,"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","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.","","Calls U::from(self).","Sector index","Solution candidates","","","","","","","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","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).","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,0,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,38,0,0,39,40,39,40,40,40,40,49,49,0,0,0,49,49,49,42,0,0,49,49,0,0,0,42,59,48,47,51,42,43,49,59,48,47,51,42,43,49,42,43,42,43,43,43,43,43,42,59,48,47,51,42,43,49,59,48,47,51,42,43,49,0,59,59,48,47,51,42,43,49,0,43,59,42,59,51,59,47,42,43,49,49,59,48,47,51,42,43,49,49,50,59,48,47,51,42,43,49,59,48,47,51,42,43,49,59,47,59,47,59,47,43,59,47,51,0,59,47,43,59,47,51,43,43,59,51,59,51,43,49,59,51,43,42,43,49,59,48,47,51,42,43,49,59,48,47,51,42,43,49,59,48,47,51,42,43,49,59,48,47,51,42,43,49,59,48,47,51,42,43,49,97,98,99,100,101,102,97,99,100,64,64,64,64,64,0,0,64,0,62,64,63,64,63,63,63,64,63,64,63,64,63,64,64,63,64,64,64,64,63,64,63,64,63,63,63,63,64,63,64,64,63,64,63,64,63,64,63,64,63,103,104,103,104,103,67,67,67,67,67,67,0,0,67,67,75,67,75,75,75,75,67,75,67,75,67,75,67,67,75,67,67,67,75,67,75,67,75,0,0,0,0,75,67,75,67,67,75,67,75,67,75,67,75,67,75,75,105,106,107,107,106,107,108,105,108,107,66,0,66,85,66,86,0,0,0,0,0,0,87,84,35,66,85,86,81,87,84,35,66,85,86,81,84,35,66,85,86,81,84,35,66,85,86,81,84,35,84,35,84,35,84,35,87,84,35,35,66,85,86,81,87,84,35,35,66,85,86,81,87,87,84,35,66,85,86,81,35,81,84,35,35,81,66,85,86,84,35,66,66,85,85,86,86,81,87,84,35,35,66,85,86,81,81,84,87,84,35,66,85,86,81,87,84,35,66,85,86,81,87,87,81,81,81,81,81,81,81,81,84,84,81,84,84,0,0,0,84,35,84,35,84,35,66,85,86,81,66,85,86,87,84,35,66,85,86,81,87,84,35,66,85,86,81,87,84,35,66,85,86,81,87,84,35,66,85,86,81,35,87,84,35,66,85,86,81,109,109,110,111,110,111,112,112],"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{{f{d}}}}}{{b{{Bn{{f{d}}}}}}}}{{{C`{d}}}{{b{{C`{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}}0{{{An{c}}{f{d}}Bd}{{Cd{Bb}}}Ah}0````{{B`c}AbCj}{ce{}{}}00{c{{Ab{{l{eg}}{Cl{e}}}}}{}{}n}{c{{Ab{e}}}{}{}}0000000{cCn{}}00033333333`{{D`DbDdc{f{Df}}{Dj{Dh}}}{{C`{{Dl{{An{c}}}}}}}Ah}{{D`DbDdcDf}{{Dj{{Dl{c}}}}}Ah}`55{{{Dl{c}}}{{Dl{c}}}Aj}{{ce}Bb{}{}}{Bdc{}}0{BdBb}{{{Dl{c}}Bh}BjBl}{cc{}}{{}Bd}<``<::9<<``{DnDn}{E`{{Cd{Bb}}}}10{{E`Eb}{{Cd{Bb}}}}{{E`{f{d}}Eb}{{Cd{Bb}}}}0`````````````````{ce{}{}}0000000000000{EdEd}{EfEf}<<{c{{Ab{EfEh}}}Ej}{{{f{d}}}{{Ab{cEh}}}{}}{{El{f{d}}}{{Ab{cEh}}}{}}{{Elc}{{Ab{eEh}}}Ej{}}{{}Ed}{Bdc{}}0000000000000{{{En{c}}}{{Ab{F`Fb}}}Fd}`{BdBb}000000{{F`{Ff{c}}}{{Ab{EfFb}}}Fh}{{Efc}Bb{FjFl}}`{{EdEd}Fn}````{{EdBh}Bj}{{EfBh}Bj}{{FbBh}Bj}0{cc{}}000000{G`Fb}{{FdGbEd}{{Gd{{Bn{Ch}}}}}}{{}Bd}000000{ce{}{}}000000``````````{{{Gf{ce}}}{{Ab{EfFb}}}FhFd}````````````{EfBd}{Fb{{Dj{Gh}}}}``{{c{f{d}}}{{C`{d}}}{}}44{cGj{}}{c{{Ab{e}}}{}{}}0000000000000{cCn{}}00000077777777777777``````````````````{Gl{{Dj{Dd}}}}8888{{{Gn{c}}}{{Gn{c}}}Aj}{{ce}Bb{}{}}{Bdc{}}000{BdBb}0{{H`Bh}Bj}0{{{Gn{c}}Bh}BjBl}{HbH`}{cc{}}{HdH`}{HfH`}2{{}Bd}0{ce{}{}}0{{{Gn{c}}eHhHji}{{Ab{{`{{Gl{}{{Hl{{Ab{{Hn{D`e}}H`}}}}}}}}H`}}}AhI`Fh{{Id{Ib}{{Cf{g}}}}}}{{{Gn{c}}}FnAh}{{{Gn{c}}}BdAh}{H`{{Dj{Gh}}}}4{cGj{}}{c{{Ab{e}}}{}{}}000{cCn{}}07777``````````````7777{IfIf}{{ce}Bb{}{}}`{Bdc{}}000{BdBb}0{{HfBh}Bj}0{{IfBh}Bj}{HdHf}{cc{}}{HbHf}1{{}Bd}0{ce{}{}}0{{IhIjDf{Af{ce}}Hj}{{Ab{IlHf}}}AhAl}{{IhIn{J`{El}}Jbc{Af{eg}}}{{Ab{{Bn{{J`{{Dj{Jd}}}}}}Hf}}}FhAhAl}{{{J`{{Dj{Jd}}}}IhHj}{{Ab{{Bn{{J`{Jd}}}}Hf}}}}{{{J`{{Dj{Jd}}}}IhHj}{{Ab{{`{{Jf{}{{Hl{Jd}}}}}}Hf}}}}`{Hf{{Dj{Gh}}}}5{cGj{}}{c{{Ab{e}}}{}{}}000{cCn{}}08888```````````````````````88888888888888{JhJh}{DfDf}{HdHd}{JjJj}{JlJl}{JbJb}{{ce}Bb{}{}}00000{c{{Ab{JhEh}}}Ej}{c{{Ab{DfEh}}}Ej}{{{f{d}}}{{Ab{cEh}}}{}}0{{El{f{d}}}{{Ab{cEh}}}{}}0{{Elc}{{Ab{eEh}}}Ej{}}0{Bdc{}}0{Dfc{}}1111111101111{JnBb}{BdBb}000000{Df{{C`{d}}}}{{Jb{f{d}}}{{Ab{BbJj}}}}{{Jhc}Bb{FjFl}}{{Dfc}Bb{FjFl}}{{}Bd}{InBd}{{HdHd}Fn}{{JjJj}Fn}{{JlJl}Fn}{{JhBh}Bj}{{DfBh}Bj}{{HdBh}Bj}0{{JjBh}Bj}0{{JlBh}Bj}0{{JbBh}Bj}{cc{}}00{JhDf}1111{{{f{d}}In}{{Ab{JbHd}}}}`======={ce{}{}}000000{Jn{{`{{Jf{}{{Hl{{`{{Kb{}{{K`{Fn}}}}}}}}}}}}}}{Jn{{`{{Jf{}{{Hl{{`{{Kd{}{{K`{Fn}}}}}}}}}}}}}}{Jb{{f{{Kf{{J`{d}}}}}}}}{Jb{{`{{Jf{}{{Hl{Jn}}}}}}}}{{JbIh}{{`{{Kl{}{{Hl{{Kj{KhFnBd}}}}}}}}}}{{JbKh}{{Ab{{`{{Kl{}{{Hl{Fn}}}}}}Jl}}}}{{JbKh}{{Ab{{`{{Kl{}{{Hl{{Kj{IhFn}}}}}}}}Jl}}}}{InJb}{Jb{{f{Kh}}}}{{JbIh}{{`{{Kn{}{{Hl{{Dj{{Kj{BdFn}}}}}}}}}}}}`{Jh{{Bn{{J`{El}}}}}}{Jb{{Bn{{J`{In}}}}}}``{InBd}00{JhBd}{DfBd}{{c{f{d}}}{{C`{d}}}{}}0{ce{}{}}00000{cGj{}}00{c{{Ab{e}}}{}{}}0000000000000{cCn{}}0000003333333{{Dfe}c{}{{L`{{f{d}}}{{Cf{c}}}}}}4444444````````","c":[],"p":[[5,"AsyncReadBytes",0],[1,"u8"],[1,"slice"],[10,"AsMut",611],[10,"Unpin",612],[5,"BitSlice",613],[10,"BitOrder",614],[6,"Error",615],[6,"Result",616],[10,"FromByteSlice",615],[6,"ReadAt",0],[10,"ReadAtSync",0],[10,"Clone",617],[10,"ReadAtAsync",0],[5,"ReadAtOffset",0],[5,"FarmerProtocolInfo",0],[1,"unit"],[1,"usize"],[10,"Deserializer",618],[5,"Formatter",619],[8,"Result",619],[10,"Debug",619],[5,"Box",620],[5,"Vec",621],[1,"never"],[8,"Result",622],[17,"Output"],[10,"Future",623],[10,"Serializer",624],[6,"BitSpanError",625],[5,"TypeId",626],[5,"PublicKey",627],[8,"Blake3Hash",627],[8,"SolutionRange",627],[5,"SectorMetadataChecksummed",424],[8,"SectorIndex",627],[6,"Option",628],[5,"AuditResult",102],[10,"OpenOptionsExt",125],[10,"FileExt",125],[1,"u64"],[6,"PieceGetterRetryPolicy",134],[5,"PlottedSector",134],[5,"Error",629],[10,"Input",630],[1,"u32"],[5,"DownloadSectorOptions",134],[5,"DownloadedSector",134],[6,"PlottingError",134],[10,"PieceGetter",134],[5,"EncodeSectorOptions",134],[10,"Table",631],[10,"Output",630],[10,"Sized",612],[1,"bool"],[5,"AcquireError",632],[5,"PieceIndex",633],[5,"Pin",634],[5,"PlotSectorOptions",134],[10,"Error",635],[5,"String",636],[10,"ProvableSolutions",307],[5,"SolutionCandidates",307],[6,"ProvingError",307],[5,"Error",622],[6,"SectorContentsMapFromBytesError",424],[6,"ReadingError",362],[5,"Kzg",637],[5,"ErasureCoding",638],[17,"Item"],[5,"Solution",627],[10,"Copy",612],[5,"PosSeed",627],[10,"FnMut",639],[5,"PlotRecord",362],[5,"PieceOffset",633],[5,"SectorId",627],[5,"Piece",633],[1,"u16"],[1,"array"],[5,"SectorContentsMap",424],[5,"Scalar",640],[10,"ExactSizeIterator",641],[5,"SectorMetadata",424],[6,"SectorContentsMapEncodeIntoError",424],[6,"SectorContentsMapIterationError",424],[5,"EncodedChunksUsed",424],[17,"Target"],[10,"Deref",642],[10,"DerefMut",642],[5,"BitArray",643],[5,"SBucket",633],[1,"tuple"],[10,"Iterator",644],[10,"IndexedParallelIterator",645],[10,"FnOnce",639],[15,"FailedToRetrievePiece",298],[15,"FailedToAcquirePermit",298],[15,"BadSectorOutputSize",298],[15,"BadSectorMetadataOutputSize",298],[15,"PieceNotFound",298],[15,"PieceRecoveryFailed",298],[15,"FailedToCreateChunkWitness",357],[15,"FailedToCreatePolynomialForRecord",357],[15,"WrongRecordSizeAfterDecoding",414],[15,"FailedToReadChunk",414],[15,"InvalidChunk",414],[15,"FailedToErasureDecodeRecord",414],[15,"InvalidBytesLength",603],[15,"InvalidBytesLength",605],[15,"InvalidEncodedRecordChunks",605],[15,"SBucketOutOfRange",609]],"b":[[44,"impl-From%3CBox%3C%5Bu8%5D%3E%3E-for-AsyncReadBytes%3CBox%3C%5Bu8%5D%3E%3E"],[45,"impl-From%3CVec%3Cu8%3E%3E-for-AsyncReadBytes%3CVec%3Cu8%3E%3E"],[69,"impl-ReadAtAsync-for-%26ReadAtOffset%3C\'_,+T%3E"],[70,"impl-ReadAtAsync-for-ReadAtOffset%3C\'_,+T%3E"],[71,"impl-ReadAtSync-for-ReadAtOffset%3C\'_,+T%3E"],[72,"impl-ReadAtSync-for-%26ReadAtOffset%3C\'_,+T%3E"],[207,"impl-Debug-for-PlottingError"],[208,"impl-Display-for-PlottingError"],[329,"impl-Debug-for-ProvingError"],[330,"impl-Display-for-ProvingError"],[332,"impl-From%3CError%3E-for-ProvingError"],[334,"impl-From%3CSectorContentsMapFromBytesError%3E-for-ProvingError"],[335,"impl-From%3CReadingError%3E-for-ProvingError"],[384,"impl-Display-for-ReadingError"],[385,"impl-Debug-for-ReadingError"],[387,"impl-From%3CSectorContentsMapFromBytesError%3E-for-ReadingError"],[389,"impl-From%3CError%3E-for-ReadingError"],[505,"impl-Display-for-SectorContentsMapFromBytesError"],[506,"impl-Debug-for-SectorContentsMapFromBytesError"],[507,"impl-Debug-for-SectorContentsMapEncodeIntoError"],[508,"impl-Display-for-SectorContentsMapEncodeIntoError"],[509,"impl-Display-for-SectorContentsMapIterationError"],[510,"impl-Debug-for-SectorContentsMapIterationError"]]}],\ +["subspace_farmer",{"doc":"subspace-farmer library implementation overview","t":"FSEFENNNNNNNNNNNNNNNNNNNNNNNNNNNENNCNNNCNCNNNCNNNNNNCNNNNNNNNNNCNNIKKMMMMMMMMMMMFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHPPGPPPPPPPPPPPPPPPPPPPPPPPPPPPEPPPPPPPPPPPPTPPPPPTPPPGPPGGGFGGGFFGGPPPPPPPPNONNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNNNNNNOOOCONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONONNNONNNNCNOCNNNNOONNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOPFPFPPPGGPPPPFFPFGPPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONOCOOOONNNNNONNOOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOFNNNNNNNNNNNNNNNNPPFGPFPPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOFNNNNNNNNNNNNNNNNNNFFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNNNNNFFHNNNNNNNHNNNNNNNCNNNNNNNNNHCNNHCHCHNHNNNNNNNNNNNNFNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNFNNNNNNNNNNNNNNNNNNNNPPPPPGNNNNNNNNNNHNNNNNN","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","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"],[975,"subspace_farmer::utils::farmer_piece_getter"],[991,"subspace_farmer::utils::piece_validator"],[1010,"subspace_farmer::utils::readers_and_pieces"],[1031,"subspace_farmer::utils::ss58"],[1054,"subspace_core_primitives::segments"],[1055,"core::future::future"],[1056,"alloc::boxed"],[1057,"core::pin"],[1058,"core::result"],[1059,"std::path"],[1060,"core::convert"],[1061,"core::fmt"],[1062,"core::fmt"],[1063,"core::option"],[1064,"subspace_core_primitives::pieces"],[1065,"schnorrkel::keys"],[1066,"schnorrkel::keys"],[1067,"schnorrkel::sign"],[1068,"subspace_rpc_primitives"],[1069,"subspace_rpc_primitives"],[1070,"core::fmt"],[1071,"subspace_core_primitives::pieces"],[1072,"core::ops::function"],[1073,"alloc::sync"],[1074,"event_listener_primitives::handler_id"],[1075,"libp2p_kad::record"],[1076,"subspace_farmer_components::plotting"],[1077,"core::error"],[1078,"core::cmp"],[1079,"std::path"],[1080,"parity_scale_codec::codec"],[1081,"serde::de"],[1082,"parity_scale_codec::codec"],[1083,"subspace_farmer_components::plotting"],[1084,"ulid"],[1085,"core::hash"],[1086,"std::io::error"],[1087,"core::marker"],[1088,"subspace_farmer_components::plotting"],[1089,"subspace_farmer_components::sector"],[1090,"anyhow"],[1091,"serde::ser"],[1092,"alloc::string"],[1093,"subspace_core_primitives"],[1094,"subspace_farmer_components::proving"],[1095,"subspace_farmer_components"],[1096,"subspace_proof_of_space"],[1097,"rayon_core"],[1098,"subspace_core_primitives::pieces"],[1099,"core::ops::function"],[1100,"tokio::runtime::task::join"],[1101,"core::num::error"],[1102,"core::task::wake"],[1103,"core::task::poll"],[1104,"rayon_core::registry"],[1105,"core::ops::function"],[1106,"subspace_networking::utils::piece_provider"],[1107,"subspace_networking::node"],[1108,"subspace_core_primitives::crypto::kzg"],[1109,"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 …","","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,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}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}1{HfGl}{HhFb}333{HfGn}{HjGn}55{GlHb}6{{{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{KnHl}{KjHl}{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{{{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}}`{{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",1054],[10,"Future",1055],[5,"Box",1056],[5,"Pin",1057],[5,"Identity",0],[1,"unit"],[6,"Result",1058],[5,"Path",1059],[10,"AsRef",1060],[1,"usize"],[1,"u8"],[1,"slice"],[5,"Formatter",1061],[8,"Result",1061],[1,"u64"],[1,"str"],[6,"Error",1062],[6,"Option",1063],[5,"PieceIndex",1064],[5,"PublicKey",1065],[5,"SecretKey",1065],[5,"Vec",1066],[5,"Signature",1067],[5,"RewardSignatureResponse",1068],[5,"SolutionResponse",1068],[5,"TypeId",1069],[10,"NodeClient",66],[10,"NodeClientExt",66],[5,"PieceCache",80],[5,"CacheWorker",80],[10,"Debug",1061],[5,"Key",1070],[5,"Piece",1064],[5,"PeerId",1071],[1,"tuple"],[10,"Fn",1072],[5,"Arc",1073],[5,"HandlerId",1074],[5,"ProviderRecord",1070],[5,"DiskPieceCache",787],[5,"Receiver",1075],[10,"PieceGetter",1076],[17,"Output"],[10,"Error",1077],[6,"SingleDiskFarmInfo",120],[6,"SectorPlottingDetails",120],[6,"SectorExpirationDetails",120],[6,"SingleDiskFarmId",120],[6,"SectorUpdate",120],[6,"Ordering",1078],[5,"PathBuf",1059],[6,"SingleDiskFarmSummary",120],[5,"Error",1079],[10,"Input",1080],[1,"u32"],[10,"Deserializer",1081],[5,"SingleDiskFarm",120],[10,"Output",1080],[10,"Sized",1082],[1,"bool"],[6,"PlottingError",120],[6,"SingleDiskFarmError",120],[6,"SingleDiskFarmScrubError",120],[6,"BackgroundTaskError",120],[6,"PlottingError",1076],[5,"Error",1083],[5,"Ulid",1084],[6,"DiskPieceCacheError",787],[6,"FarmingError",552],[1,"array"],[10,"Hasher",1085],[8,"Result",1083],[5,"SingleDiskFarmOptions",120],[10,"Clone",1086],[10,"Send",1082],[10,"Sync",1082],[5,"PublicKey",1087],[1,"u16"],[5,"PieceReader",851],[17,"Item"],[5,"PlottedSector",1076],[10,"Iterator",1088],[5,"SectorMetadataChecksummed",1089],[8,"Result",1090],[10,"Serializer",1091],[5,"String",1092],[8,"SectorIndex",1087],[5,"SingleDiskFarmInfoLock",120],[5,"PlotAudit",552],[5,"PlotAuditOptions",552],[5,"Solution",1087],[6,"ProvingError",1093],[10,"ProvableSolutions",1093],[6,"AuditingError",1094],[10,"ReadAtSync",1095],[10,"Table",1096],[5,"AuditingDetails",552],[6,"ProvingResult",552],[5,"ProvingDetails",552],[6,"FarmingNotification",552],[5,"DecodedFarmingError",552],[5,"ThreadPoolBuildError",1097],[5,"RayonFiles",770],[5,"Offset",787],[5,"PieceOffset",1064],[5,"PlottingThreadPoolManager",870],[5,"PlottingThreadPoolsGuard",870],[5,"PlottingThreadPoolPair",870],[5,"NonZeroUsize",1098],[10,"FnMut",1072],[5,"CpuCoreSet",924],[10,"ExactSizeIterator",1099],[5,"AsyncJoinOnDrop",924],[5,"JoinHandle",1100],[5,"ParseIntError",1101],[5,"Context",1102],[6,"Poll",1103],[5,"ThreadBuilder",1104],[10,"FnOnce",1072],[5,"Canceled",1075],[5,"FarmerPieceGetter",975],[6,"PieceGetterRetryPolicy",1076],[10,"PieceValidator",1105],[5,"PieceProvider",1105],[5,"ReadersAndPieces",1010],[8,"Mutex",1106],[5,"SegmentCommitmentPieceValidator",991],[5,"Node",1107],[5,"Kzg",1108],[5,"SegmentCommitment",1054],[5,"LruCache",1109],[6,"Ss58ParsingError",1031],[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-Debug-for-PlottingError"],[308,"impl-Display-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-Display-for-BackgroundTaskError"],[318,"impl-Debug-for-BackgroundTaskError"],[325,"impl-From%3CPlottingError%3E-for-PlottingError"],[327,"impl-From%3CError%3E-for-PlottingError"],[332,"impl-From%3CError%3E-for-SingleDiskFarmError"],[333,"impl-From%3CDiskPieceCacheError%3E-for-SingleDiskFarmError"],[336,"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-Display-for-ProvingResult"],[657,"impl-Debug-for-ProvingResult"],[660,"impl-Display-for-DecodedFarmingError"],[661,"impl-Debug-for-DecodedFarmingError"],[662,"impl-Display-for-FarmingError"],[663,"impl-Debug-for-FarmingError"],[671,"impl-From%3CAuditingError%3E-for-FarmingError"],[672,"impl-From%3CProvingError%3E-for-FarmingError"],[673,"impl-From%3CError%3E-for-FarmingError"],[675,"impl-From%3CThreadPoolBuildError%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"],[1042,"impl-Display-for-Ss58ParsingError"],[1043,"impl-Debug-for-Ss58ParsingError"]]}],\ +["subspace_farmer_components",{"doc":"Components of the reference implementation of Subspace …","t":"PFFGKFKPNNNNCNNNNNNNNNNNNNNNNNNNNNNNNNNNCNNNNNNNNNNONNNNNNNNNOONNCCMMNNNNCOOCNNNNNNNNNNNNNNNNNNNNNNNNNFGPHHONNNNNNNNNNNNNNNNNNNNNOONNNNNNNNNNNNOOOKKMMMMMMMPPFFFPPPPKGPPFFGPNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNHONNNNNNNHNONOOOONNNNNNNNNNNNMNNNNNNNNNNNNNNOOOOOOOOOOHOOOOOOOOOOOONNOONNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOOOPPPPPKGPFMNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOPPPPPPFGPNNNNNNONNNNNNNNNNNNNNNNNNHHHHONNNNNNNNNNNNNOOOOOOOOOOOPFPPPPFGGGFFNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNONNNNNNNNNNNNNNNNNNNNNNNNONNOOHHHNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNOOOOOOOO","n":["Async","AsyncReadBytes","FarmerProtocolInfo","ReadAt","ReadAtAsync","ReadAtOffset","ReadAtSync","Sync","as_mut","as_mut_bits","as_mut_byte_slice","as_mut_slice_of","auditing","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone_into","clone_into","clone_into","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deserialize","drop","drop","drop","drop","file_ext","fmt","fmt","from","from","from","from","from","from","from_async","from_sync","history_size","init","init","init","init","into","into","into","into","into_inner","max_pieces_in_sector","min_sector_lifetime","offset","offset","plotting","proving","read_at","read_at","read_at","read_at","read_at","read_at","reading","recent_history_fraction","recent_segments","sector","serialize","to_owned","to_owned","to_owned","try_as_mut_bits","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","vzip","vzip","vzip","vzip","AuditResult","AuditingError","SBucketReading","audit_plot_sync","audit_sector_sync","best_solution_distance","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deref","deref","deref_mut","deref_mut","drop","drop","fmt","fmt","fmt","from","from","init","init","into","into","sector_index","solution_candidates","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","unique_saturated_into","unique_saturated_into","vzip","vzip","error","s_bucket_audit_index","sector_index","FileExt","OpenOptionsExt","advise_random_access","advise_random_access","advise_sequential_access","advise_sequential_access","preallocate","read_exact_at","write_all_at","BadSectorMetadataOutputSize","BadSectorOutputSize","DownloadSectorOptions","DownloadedSector","EncodeSectorOptions","FailedToAcquirePermit","FailedToRetrievePiece","InvalidErasureCodingInstance","Limited","PieceGetter","PieceGetterRetryPolicy","PieceNotFound","PieceRecoveryFailed","PlotSectorOptions","PlottedSector","PlottingError","Unlimited","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone_into","clone_into","decode","decode_all","decode_all_with_depth_limit","decode_with_depth_limit","default","deref","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","download_sector","downloading_semaphore","drop","drop","drop","drop","drop","drop","drop","encode_sector","encode_to","encoding_semaphore","eq","erasure_coding","erasure_coding","farmer_protocol_info","farmer_protocol_info","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","get_piece","init","init","init","init","init","init","init","into","into","into","into","into","into","into","kzg","kzg","piece_getter","piece_getter","piece_getter_retry_policy","piece_getter_retry_policy","piece_indexes","pieces_in_sector","pieces_in_sector","pieces_in_sector","plot_sector","public_key","public_key","sector_id","sector_index","sector_index","sector_index","sector_index","sector_metadata","sector_metadata_output","sector_metadata_output","sector_output","sector_output","size_hint","source","table_generator","table_generator","to_keyed_vec","to_owned","to_owned","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","vzip","vzip","vzip","vzip","vzip","vzip","vzip","error","error","expected","expected","piece_index","piece_index","piece_index","provided","provided","FailedToCreateChunkWitness","FailedToCreatePolynomialForRecord","FailedToDecodeSectorContentsMap","InvalidErasureCodingInstance","Io","ProvableSolutions","ProvingError","RecordReadingError","SolutionCandidates","best_solution_distance","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","deref","deref","deref_mut","deref_mut","drop","drop","fmt","fmt","fmt","from","from","from","from","from","init","init","into","into","into_solutions","is_empty","is_fatal","len","source","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","unique_saturated_into","unique_saturated_into","vzip","vzip","chunk_offset","error","error","piece_offset","piece_offset","ChecksumMismatch","FailedToDecodeSectorContentsMap","FailedToErasureDecodeRecord","FailedToReadChunk","InvalidChunk","Io","PlotRecord","ReadingError","WrongRecordSizeAfterDecoding","borrow","borrow","borrow_mut","borrow_mut","clone","clone_into","commitment","deref","deref","deref_mut","deref_mut","drop","drop","fmt","fmt","fmt","from","from","from","from","init","init","into","into","is_fatal","read_piece","read_sector_record_chunks","recover_extended_record_chunks","recover_source_record_chunks","scalars","source","to_owned","to_string","try_from","try_from","try_into","try_into","type_id","type_id","unique_saturated_into","unique_saturated_into","vzip","vzip","witness","actual","chunk_location","chunk_location","encoded_chunk_used","error","error","error","expected","piece_offset","s_bucket","ChecksumMismatch","EncodedChunksUsed","InvalidBytesLength","InvalidBytesLength","InvalidEncodedRecordChunks","SBucketOutOfRange","SectorContentsMap","SectorContentsMapEncodeIntoError","SectorContentsMapFromBytesError","SectorContentsMapIterationError","SectorMetadata","SectorMetadataChecksummed","borrow","borrow","borrow","borrow","borrow","borrow","borrow","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","borrow_mut","clone","clone","clone","clone","clone","clone","clone_into","clone_into","clone_into","clone_into","clone_into","clone_into","decode","decode","decode_all","decode_all","decode_all_with_depth_limit","decode_all_with_depth_limit","decode_with_depth_limit","decode_with_depth_limit","deref","deref","deref","deref","deref","deref","deref","deref","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","deref_mut","drop","drop","drop","drop","drop","drop","drop","drop","encode","encode_into","encode_to","encode_to","encoded_size","encoded_size","eq","eq","eq","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","fmt","from","from","from","from","from","from","from","from","from_bytes","history_size","init","init","init","init","init","init","init","into","into","into","into","into","into","into","iter","iter_mut","iter_record_bitfields","iter_record_bitfields_mut","iter_record_chunk_to_plot","iter_s_bucket_encoded_record_chunks_used","iter_s_bucket_records","new","num_encoded_record_chunks","par_iter_record_chunk_to_plot","pieces_in_sector","s_bucket_offsets","s_bucket_sizes","s_bucket_sizes","sector_index","sector_record_chunks_size","sector_record_metadata_size","sector_size","size_hint","size_hint","to_keyed_vec","to_keyed_vec","to_owned","to_owned","to_owned","to_owned","to_owned","to_owned","to_string","to_string","to_string","try_from","try_from","try_from","try_from","try_from","try_from","try_from","try_into","try_into","try_into","try_into","try_into","try_into","try_into","type_id","type_id","type_id","type_id","type_id","type_id","type_id","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","unique_saturated_into","using_encoded","vzip","vzip","vzip","vzip","vzip","vzip","vzip","actual","expected","actual","actual","expected","max","max","provided"],"q":[[0,"subspace_farmer_components"],[102,"subspace_farmer_components::auditing"],[143,"subspace_farmer_components::auditing::AuditingError"],[146,"subspace_farmer_components::file_ext"],[155,"subspace_farmer_components::plotting"],[319,"subspace_farmer_components::plotting::PlottingError"],[328,"subspace_farmer_components::proving"],[379,"subspace_farmer_components::proving::ProvingError"],[384,"subspace_farmer_components::reading"],[437,"subspace_farmer_components::reading::ReadingError"],[447,"subspace_farmer_components::sector"],[626,"subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"],[628,"subspace_farmer_components::sector::SectorContentsMapFromBytesError"],[632,"subspace_farmer_components::sector::SectorContentsMapIterationError"],[634,"core::convert"],[635,"core::marker"],[636,"bitvec::slice"],[637,"bitvec::order"],[638,"byte_slice_cast"],[639,"core::result"],[640,"byte_slice_cast"],[641,"serde::de"],[642,"core::fmt"],[643,"core::fmt"],[644,"alloc::boxed"],[645,"std::io::error"],[646,"core::future::future"],[647,"serde::ser"],[648,"bitvec::ptr::span"],[649,"core::any"],[650,"subspace_core_primitives"],[651,"subspace_core_primitives"],[652,"alloc::string"],[653,"parity_scale_codec::error"],[654,"parity_scale_codec::codec"],[655,"subspace_proof_of_space"],[656,"parity_scale_codec::codec"],[657,"subspace_core_primitives::pieces"],[658,"core::pin"],[659,"core::error"],[660,"std::io::error"],[661,"subspace_erasure_coding"],[662,"subspace_core_primitives"],[663,"subspace_core_primitives::pieces"],[664,"core::iter::traits::exact_size"],[665,"core::ops::deref"],[666,"core::ops::deref"],[667,"subspace_core_primitives::pieces"],[668,"rayon::iter"],[669,"core::ops::function"]],"d":["Async variant","Container or asynchronously reading bytes using in …","Information about the protocol necessary for farmer …","Enum to encapsulate the selection between ReadAtSync and […","Async version of ReadAt, it is neither Send nor Sync and …","Reader with fixed offset added to all attempted reads","Sync version of ReadAt, it is both Send and Sync and is …","Sync variant","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","File extension trait","","","Returns the argument unchanged.","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Instantiate ReadAt from some ReadAtAsync implementation","Instantiate ReadAt from some ReadAtSync implementation","Size of the blockchain history","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Extract inner value","How many pieces one sector is supposed to contain (max)","Minimum lifetime of a plotted sector, measured in archived …","Get implementation of ReadAtSync that add specified offset …","Get implementation of ReadAtAsync that add specified …","","","Fill the buffer by reading bytes at a specific offset","Fill the buffer by reading bytes at a specific offset and …","","","","","","Fraction of pieces from the “recent history” (…","Number of latest archived segments that are considered “…","","","","","","","","","","","","","","","","","","","","","","","","","","","Result of sector audit","Errors that happen during proving","Failed read s-bucket","Audit the whole plot and generate streams of solutions","Audit a single sector and generate a stream of solutions.","Best solution distance found","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Calls U::from(self).","Calls U::from(self).","Sector index","Solution candidates","","","","","","","","","","","","","Low-level error","S-bucket audit index","Sector index","Extension convenience trait that allows pre-allocating …","Extension convenience trait that allows setting some file …","Advise OS/file system that file will use random access and …","Advise OS/file system that file will use random access and …","Advise OS/file system that file will use sequential access …","Advise OS/file system that file will use sequential access …","Make sure file has specified number of bytes allocated for …","Read exact number of bytes at a specific offset","Write all provided bytes at a specific offset","Bad sector metadata output size","Bad sector output size","Options for sector downloading","Opaque sector downloaded and ready for encoding","Options for encoding a sector.","Failed to acquire permit","Failed to retrieve piece","Invalid erasure coding instance","Retry N times (including zero)","Duplicate trait for the …","Defines retry policy on error during piece acquiring.","Piece not found, can’t create sector, this should never …","Can’t recover missing piece","Options for plotting a sector.","Information about sector that was plotted","Plotting status","No restrictions on retries","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Download sector for plotting.","Semaphore for part of the plotting when farmer downloads …","","","","","","","","","","Semaphore for part of the plotting when farmer encodes …","","Erasure coding instance","Erasure coding instance","Farmer protocol info","Farmer protocol info","","","","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","KZG instance","KZG instance","Getter for pieces of archival history","Getter for pieces of archival history","Retry policy for piece getter","Retry policy for piece getter","Indexes of pieces that were plotted","How many pieces should sector contain","How many pieces should sector contain","How many pieces should sector contain","Plot a single sector.","Public key corresponding to sector","Public key corresponding to sector","Sector ID","Sector index","Sector index","Sector index","Sector index","Sector metadata","Where plotted sector metadata should be written, vector …","Where plotted sector metadata should be written, vector …","Where plotted sector should be written, vector must either …","Where plotted sector should be written, vector must either …","","","Proof of space table generator","Proof of space table generator","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Lower-level error","Lower-level error","Expected size","Expected size","Piece index","Piece index","Piece index","Actual size","Actual size","Failed to create chunk witness","Failed to create polynomial for record","Failed to decode sector contents map","Invalid erasure coding instance","I/O error occurred","Solutions that can be proven if necessary.","Errors that happen during proving","Record reading error","Container for solution candidates.","Best solution distance found, None in case there are no …","","","","","","","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","","Calls U::from(self).","Calls U::from(self).","Turn solution candidates into actual solutions","Returns true if no candidates inside","Whether this error is fatal and makes farm unusable","Total number of candidates","","","","","","","","","","","","","","Chunk index","Lower-level error","Lower-level error","Piece offset","Piece offset","Checksum mismatch","Failed to decode sector contents map","Failed to erasure-decode record","Failed to read chunk.","Invalid chunk, possible disk corruption","I/O error occurred","Record contained in the plot","Errors that happen during reading","Wrong record size after decoding","","","","","","","Record commitment","","","","","","","","","","","Returns the argument unchanged.","","Returns the argument unchanged.","","","Calls U::from(self).","Calls U::from(self).","Whether this error is fatal and renders farm unusable","Read piece from sector.","Read sector record chunks, only plotted s-buckets are …","Given sector record chunks recover extended record chunks …","Given sector record chunks recover source record chunks in …","Record scalars","","","","","","","","","","","","","","Record witness","Actual size in bytes","Chunk location","Chunk location","Indicates whether chunk was encoded","Low-level error","Lower-level error","Lower-level error","Expected size in bytes","Piece offset","S-bucket","Checksum mismatch","Wrapper data structure that allows to iterate mutably over …","Invalid bytes length","Invalid bytes length","Invalid number of encoded record chunks","S-bucket provided is out of range","Abstraction on top of bitfields that allow making sense of …","Error happening when trying to encode SectorContentsMap …","Error happening when trying to create SectorContentsMap …","Error happening when trying to create SectorContentsMap …","Metadata of the plotted sector","Same as SectorMetadata, but with checksums verified during …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Encode internal contents into output","","","Size of encoded checksummed sector metadata.","Size of sector contents map when encoded and stored in the …","","","","","","","","","","","","","Returns the argument unchanged.","Returns the argument unchanged.","","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Returns the argument unchanged.","Reconstruct sector contents map from bytes.","Size of the blockchain history at time of sector creation","","","","","","","","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Calls U::from(self).","Produces an iterator over encoded chunks bitfields.","Produces a mutable iterator over encoded chunks bitfields.","Iterate over individual record bitfields","Iterate mutably over individual record bitfields","Creates an iterator of …","Iterate over chunks of s-bucket indicating if encoded …","Creates an iterator of (piece_offset, encoded_chunk_used), …","Create new sector contents map initialized with zeroes to …","Number of encoded chunks in each record","Creates an iterator of …","Number of pieces stored in this sector","Returns offsets of each s-bucket relatively to the …","Returns sizes of each s-bucket","S-bucket sizes in a sector","Sector index","Size of the part of the plot containing record chunks …","Size of the part of the plot containing record metadata.","Exact sector plot size (sector contents map, record …","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","","Actual length","Expected length","Actual length","Actual number of encoded record chunks","Expected length","Max supported","Max s-bucket","Provided s-bucket"],"i":[11,0,0,0,0,0,0,11,1,1,1,1,0,1,11,15,16,1,11,15,16,11,15,16,11,15,16,1,11,15,16,1,11,15,16,16,1,11,15,16,0,15,16,1,1,1,11,15,16,11,11,16,1,11,15,16,1,11,15,16,1,16,16,12,14,0,0,12,14,15,15,15,15,0,16,16,0,16,11,15,16,1,1,11,15,16,1,11,15,16,1,11,15,16,1,11,15,16,1,11,15,16,0,0,39,0,0,38,39,38,39,38,38,38,39,38,39,38,39,38,39,39,38,39,38,39,38,39,38,38,38,38,39,39,38,39,38,39,38,39,38,39,38,98,98,98,0,0,41,42,41,42,42,42,42,51,51,0,0,0,51,51,51,44,0,0,51,51,0,0,0,44,61,50,49,53,44,45,51,61,50,49,53,44,45,51,44,45,44,45,45,45,45,45,44,61,50,49,53,44,45,51,61,50,49,53,44,45,51,0,61,61,50,49,53,44,45,51,0,45,61,44,61,53,61,49,44,45,51,51,61,50,49,53,44,45,51,51,52,61,50,49,53,44,45,51,61,50,49,53,44,45,51,61,49,61,49,61,49,45,61,49,53,0,61,49,45,61,49,53,45,45,61,53,61,53,45,51,61,53,45,44,45,51,61,50,49,53,44,45,51,61,50,49,53,44,45,51,61,50,49,53,44,45,51,61,50,49,53,44,45,51,61,50,49,53,44,45,51,99,100,101,102,103,104,99,101,102,65,65,65,65,65,0,0,65,0,63,65,64,65,64,64,64,65,64,65,64,65,64,65,65,64,65,65,65,65,64,65,64,65,64,64,64,65,64,65,64,65,65,64,65,64,65,64,65,64,65,64,105,106,105,106,105,68,68,68,68,68,68,0,0,68,68,76,68,76,76,76,76,68,76,68,76,68,76,68,68,76,68,68,68,76,68,76,68,76,68,0,0,0,0,76,68,76,68,68,76,68,76,68,76,68,76,68,76,76,107,108,109,109,108,109,110,107,110,109,66,0,66,86,66,87,0,0,0,0,0,0,88,85,35,66,86,87,82,88,85,35,66,86,87,82,85,35,66,86,87,82,85,35,66,86,87,82,85,35,85,35,85,35,85,35,88,85,35,35,66,86,87,82,88,85,35,35,66,86,87,82,88,88,85,35,66,86,87,82,35,82,85,35,35,82,66,86,87,85,35,66,66,86,86,87,87,82,88,85,35,35,66,86,87,82,82,85,88,85,35,66,86,87,82,88,85,35,66,86,87,82,88,88,82,82,82,82,82,82,82,82,85,85,82,85,85,0,0,0,85,35,85,35,85,35,66,86,87,82,66,86,87,88,85,35,66,86,87,82,88,85,35,66,86,87,82,88,85,35,66,86,87,82,88,85,35,66,86,87,82,35,88,85,35,66,86,87,82,111,111,112,113,112,113,114,114],"f":"````````{{{b{c}}}{{f{d}}}{{h{{f{d}}}}j}}{c{{l{eg}}}{}{}n}{c{{f{d}}}{}}{c{{Ab{{f{e}}A`}}}{}Ad}`{ce{}{}}0000000{{{Af{ce}}}{{Af{ce}}}{AhAj}{AlAj}}{{{An{c}}}{{An{c}}}Aj}{B`B`}{{ce}Bb{}{}}00{Bdc{}}0000000{c{{Ab{B`}}}Bf}{BdBb}000`{{{An{c}}Bh}BjBl}{{B`Bh}Bj}{cc{}}{{{Bn{d}}}{{b{{Bn{d}}}}}}{{{C`{{f{d}}}}}{{b{{C`{{f{d}}}}}}}}222{c{{Af{Cbc}}}Al}{c{{Af{cCb}}}Ah}`{{}Bd}000????{{{b{c}}}c{{h{{f{d}}}}j}}``{{AhBd}{{An{Ah}}}}{{AlBd}{{An{Al}}}}``{{Ah{f{d}}Bd}{{Cd{Bb}}}}{{AlcBd}{{`{{Ch{}{{Cf{{Cd{c}}}}}}}}}{{h{{f{d}}}}j}}{{{An{c}}eBd}{{Cd{e}}}Al{{h{{f{d}}}}j}}{{{An{c}}{f{d}}Bd}{{Cd{Bb}}}Ah}10````{{B`c}AbCj}{ce{}{}}00{c{{Ab{{l{eg}}{Cl{e}}}}}{}{}n}{c{{Ab{e}}}{}{}}0000000{cCn{}}00033333333```{{D`DbDdc{f{Df}}{Dj{Dh}}}{{Ab{{Bn{{Dl{{An{c}}}}}}Dn}}}Ah}{{D`DbDdcDf}{{Ab{{Dj{{Dl{c}}}}Dn}}}Ah}`5555{{{Dl{c}}}{{Dl{c}}}Aj}{{ce}Bb{}{}}{Bdc{}}000{BdBb}0{{DnBh}Bj}0{{{Dl{c}}Bh}BjBl}{cc{}}0{{}Bd}0==``={cE`{}}<<<<;;>>>>`````{EbEb}{Ed{{Cd{Bb}}}}10{{EdEf}{{Cd{Bb}}}}{{Ed{f{d}}Ef}{{Cd{Bb}}}}0`````````````````{ce{}{}}0000000000000{EhEh}{EjEj}>>{c{{Ab{EjEl}}}En}{{{f{d}}}{{Ab{cEl}}}{}}{{F`{f{d}}}{{Ab{cEl}}}{}}{{F`c}{{Ab{eEl}}}En{}}{{}Eh}{Bdc{}}0000000000000{{{Fb{c}}}{{Ab{FdFf}}}Fh}`{BdBb}000000{{Fd{Fj{c}}}{{Ab{EjFf}}}Fl}{{Ejc}Bb{FnG`}}`{{EhEh}Gb}````{{EhBh}Bj}{{EjBh}Bj}{{FfBh}Bj}0{cc{}}00000{GdFf}1{{FhGfEh}{{Gh{{C`{Ch}}}}}}{{}Bd}000000{ce{}{}}000000``````````{{{Gj{ce}}}{{Ab{EjFf}}}FlFh}````````````{EjBd}{Ff{{Dj{Gl}}}}``{{c{f{d}}}{{Bn{d}}}{}}44{cE`{}}{c{{Ab{e}}}{}{}}0000000000000{cCn{}}00000077777777777777``````````````````{Gn{{Dj{Dd}}}}8888{{{H`{c}}}{{H`{c}}}Aj}{{ce}Bb{}{}}{Bdc{}}000{BdBb}0{{HbBh}Bj}0{{{H`{c}}Bh}BjBl}{HdHb}{HfHb}{HhHb}{cc{}}0{{}Bd}0{ce{}{}}0{{{H`{c}}eHjHli}{{Ab{{`{{Gn{}{{Hn{{Ab{{I`{D`e}}Hb}}}}}}}}Hb}}}AhIbFl{{If{Id}{{Cf{g}}}}}}{{{H`{c}}}GbAh}{HbGb}{{{H`{c}}}BdAh}{Hb{{Dj{Gl}}}}5{cE`{}}{c{{Ab{e}}}{}{}}000{cCn{}}08888``````````````8888{IhIh}{{ce}Bb{}{}}`{Bdc{}}000{BdBb}0{{HhBh}Bj}0{{IhBh}Bj}{HfHh}{cc{}}{HdHh}1{{}Bd}0{ce{}{}}0{HhGb}{{IjIlDf{Af{ce}}Hl}{{Ab{InHh}}}AhAl}{{IjJ`{Jb{F`}}Jdc{Af{eg}}}{{Ab{{C`{{Jb{{Dj{Jf}}}}}}Hh}}}FlAhAl}{{{Jb{{Dj{Jf}}}}IjHl}{{Ab{{C`{{Jb{Jf}}}}Hh}}}}{{{Jb{{Dj{Jf}}}}IjHl}{{Ab{{`{{Jh{}{{Hn{Jf}}}}}}Hh}}}}`{Hh{{Dj{Gl}}}}6{cE`{}}{c{{Ab{e}}}{}{}}000{cCn{}}09999```````````````````````99999999999999{JjJj}{DfDf}{HdHd}{JlJl}{JnJn}{JdJd}{{ce}Bb{}{}}00000{c{{Ab{JjEl}}}En}{c{{Ab{DfEl}}}En}{{{f{d}}}{{Ab{cEl}}}{}}0{{F`{f{d}}}{{Ab{cEl}}}{}}0{{F`c}{{Ab{eEl}}}En{}}0{Bdc{}}00{Dfc{}}111111011111{K`Bb}{BdBb}000000{Df{{Bn{d}}}}{{Jd{f{d}}}{{Ab{BbJl}}}}{{Jjc}Bb{FnG`}}{{Dfc}Bb{FnG`}}{{}Bd}{J`Bd}{{HdHd}Gb}{{JlJl}Gb}{{JnJn}Gb}{{JjBh}Bj}{{DfBh}Bj}{{HdBh}Bj}0{{JlBh}Bj}0{{JnBh}Bj}0{{JdBh}Bj}{cc{}}0{JjDf}11111{{{f{d}}J`}{{Ab{JdHd}}}}`======={ce{}{}}000000{K`{{`{{Jh{}{{Hn{{`{{Kd{}{{Kb{Gb}}}}}}}}}}}}}}{K`{{`{{Jh{}{{Hn{{`{{Kf{}{{Kb{Gb}}}}}}}}}}}}}}{Jd{{f{{Kh{{Jb{d}}}}}}}}{Jd{{`{{Jh{}{{Hn{K`}}}}}}}}{{JdIj}{{`{{Kn{}{{Hn{{Kl{KjGbBd}}}}}}}}}}{{JdKj}{{Ab{{`{{Kn{}{{Hn{Gb}}}}}}Jn}}}}{{JdKj}{{Ab{{`{{Kn{}{{Hn{{Kl{IjGb}}}}}}}}Jn}}}}{J`Jd}{Jd{{f{Kj}}}}{{JdIj}{{`{{L`{}{{Hn{{Dj{{Kl{BdGb}}}}}}}}}}}}`{Jj{{C`{{Jb{F`}}}}}}{Jd{{C`{{Jb{J`}}}}}}``{J`Bd}00{JjBd}{DfBd}{{c{f{d}}}{{Bn{d}}}{}}0{ce{}{}}00000{cE`{}}00{c{{Ab{e}}}{}{}}0000000000000{cCn{}}0000003333333{{Dfe}c{}{{Lb{{f{d}}}{{Cf{c}}}}}}4444444````````","c":[],"p":[[5,"AsyncReadBytes",0],[1,"u8"],[1,"slice"],[10,"AsMut",634],[10,"Unpin",635],[5,"BitSlice",636],[10,"BitOrder",637],[6,"Error",638],[6,"Result",639],[10,"FromByteSlice",638],[6,"ReadAt",0],[10,"ReadAtSync",0],[10,"Clone",640],[10,"ReadAtAsync",0],[5,"ReadAtOffset",0],[5,"FarmerProtocolInfo",0],[1,"unit"],[1,"usize"],[10,"Deserializer",641],[5,"Formatter",642],[8,"Result",642],[10,"Debug",642],[5,"Vec",643],[5,"Box",644],[1,"never"],[8,"Result",645],[17,"Output"],[10,"Future",646],[10,"Serializer",647],[6,"BitSpanError",648],[5,"TypeId",649],[5,"PublicKey",650],[8,"Blake3Hash",650],[8,"SolutionRange",650],[5,"SectorMetadataChecksummed",447],[8,"SectorIndex",650],[6,"Option",651],[5,"AuditResult",102],[6,"AuditingError",102],[5,"String",652],[10,"OpenOptionsExt",146],[10,"FileExt",146],[1,"u64"],[6,"PieceGetterRetryPolicy",155],[5,"PlottedSector",155],[5,"Error",653],[10,"Input",654],[1,"u32"],[5,"DownloadSectorOptions",155],[5,"DownloadedSector",155],[6,"PlottingError",155],[10,"PieceGetter",155],[5,"EncodeSectorOptions",155],[10,"Table",655],[10,"Output",654],[10,"Sized",635],[1,"bool"],[5,"AcquireError",656],[5,"PieceIndex",657],[5,"Pin",658],[5,"PlotSectorOptions",155],[10,"Error",659],[10,"ProvableSolutions",328],[5,"SolutionCandidates",328],[6,"ProvingError",328],[6,"SectorContentsMapFromBytesError",447],[5,"Error",645],[6,"ReadingError",384],[5,"Kzg",660],[5,"ErasureCoding",661],[17,"Item"],[5,"Solution",650],[10,"Copy",635],[5,"PosSeed",650],[10,"FnMut",662],[5,"PlotRecord",384],[5,"PieceOffset",657],[5,"SectorId",650],[5,"Piece",657],[1,"u16"],[1,"array"],[5,"SectorContentsMap",447],[5,"Scalar",663],[10,"ExactSizeIterator",664],[5,"SectorMetadata",447],[6,"SectorContentsMapEncodeIntoError",447],[6,"SectorContentsMapIterationError",447],[5,"EncodedChunksUsed",447],[17,"Target"],[10,"Deref",665],[10,"DerefMut",665],[5,"BitArray",666],[5,"SBucket",657],[1,"tuple"],[10,"Iterator",667],[10,"IndexedParallelIterator",668],[10,"FnOnce",662],[15,"SBucketReading",143],[15,"FailedToRetrievePiece",319],[15,"FailedToAcquirePermit",319],[15,"BadSectorOutputSize",319],[15,"BadSectorMetadataOutputSize",319],[15,"PieceNotFound",319],[15,"PieceRecoveryFailed",319],[15,"FailedToCreateChunkWitness",379],[15,"FailedToCreatePolynomialForRecord",379],[15,"WrongRecordSizeAfterDecoding",437],[15,"FailedToReadChunk",437],[15,"InvalidChunk",437],[15,"FailedToErasureDecodeRecord",437],[15,"InvalidBytesLength",626],[15,"InvalidBytesLength",628],[15,"InvalidEncodedRecordChunks",628],[15,"SBucketOutOfRange",632]],"b":[[44,"impl-From%3CVec%3Cu8%3E%3E-for-AsyncReadBytes%3CVec%3Cu8%3E%3E"],[45,"impl-From%3CBox%3C%5Bu8%5D%3E%3E-for-AsyncReadBytes%3CBox%3C%5Bu8%5D%3E%3E"],[69,"impl-ReadAtAsync-for-ReadAtOffset%3C\'_,+T%3E"],[70,"impl-ReadAtSync-for-%26ReadAtOffset%3C\'_,+T%3E"],[71,"impl-ReadAtAsync-for-%26ReadAtOffset%3C\'_,+T%3E"],[72,"impl-ReadAtSync-for-ReadAtOffset%3C\'_,+T%3E"],[120,"impl-Display-for-AuditingError"],[121,"impl-Debug-for-AuditingError"],[228,"impl-Debug-for-PlottingError"],[229,"impl-Display-for-PlottingError"],[350,"impl-Display-for-ProvingError"],[351,"impl-Debug-for-ProvingError"],[353,"impl-From%3CSectorContentsMapFromBytesError%3E-for-ProvingError"],[354,"impl-From%3CError%3E-for-ProvingError"],[355,"impl-From%3CReadingError%3E-for-ProvingError"],[406,"impl-Display-for-ReadingError"],[407,"impl-Debug-for-ReadingError"],[409,"impl-From%3CError%3E-for-ReadingError"],[411,"impl-From%3CSectorContentsMapFromBytesError%3E-for-ReadingError"],[528,"impl-Display-for-SectorContentsMapFromBytesError"],[529,"impl-Debug-for-SectorContentsMapFromBytesError"],[530,"impl-Debug-for-SectorContentsMapEncodeIntoError"],[531,"impl-Display-for-SectorContentsMapEncodeIntoError"],[532,"impl-Debug-for-SectorContentsMapIterationError"],[533,"impl-Display-for-SectorContentsMapIterationError"]]}],\ ["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_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"]]}],\ diff --git a/settings.html b/settings.html index 51589d0c3f..0cd8437ded 100644 --- a/settings.html +++ b/settings.html @@ -1,2 +1,2 @@ -Settings
-

Rustdoc settings

Back
\ No newline at end of file +Settings
+

Rustdoc settings

Back
\ No newline at end of file diff --git a/src/subspace_farmer/lib.rs.html b/src/subspace_farmer/lib.rs.html index 03b02fc477..ce766a369f 100644 --- a/src/subspace_farmer/lib.rs.html +++ b/src/subspace_farmer/lib.rs.html @@ -53,10 +53,12 @@

Files

51 52 53 +54 
#![feature(
     array_chunks,
     assert_matches,
     const_option,
+    exact_size_is_empty,
     hash_extract_if,
     impl_trait_in_assoc_type,
     int_roundings,
diff --git a/src/subspace_farmer/single_disk_farm.rs.html b/src/subspace_farmer/single_disk_farm.rs.html
index 4f4e7961a8..0e53bd845b 100644
--- a/src/subspace_farmer/single_disk_farm.rs.html
+++ b/src/subspace_farmer/single_disk_farm.rs.html
@@ -1983,37 +1983,6 @@ 
Files

 1981
 1982
 1983
-1984
-1985
-1986
-1987
-1988
-1989
-1990
-1991
-1992
-1993
-1994
-1995
-1996
-1997
-1998
-1999
-2000
-2001
-2002
-2003
-2004
-2005
-2006
-2007
-2008
-2009
-2010
-2011
-2012
-2013
-2014
 
pub mod farming;
 pub mod piece_cache;
 pub mod piece_reader;
@@ -2025,14 +1994,16 @@ 
Files

 use crate::single_disk_farm::farming::rayon_files::RayonFiles;
 pub use crate::single_disk_farm::farming::FarmingError;
 use crate::single_disk_farm::farming::{
-    farming, slot_notification_forwarder, AuditEvent, FarmingOptions, PlotAudit,
+    farming, slot_notification_forwarder, FarmingNotification, FarmingOptions, PlotAudit,
 };
 use crate::single_disk_farm::piece_cache::{DiskPieceCache, DiskPieceCacheError};
 use crate::single_disk_farm::piece_reader::PieceReader;
-pub use crate::single_disk_farm::plotting::PlottingError;
 use crate::single_disk_farm::plotting::{
     plotting, plotting_scheduler, PlottingOptions, PlottingSchedulerOptions,
 };
+pub use crate::single_disk_farm::plotting::{
+    PlottingError, SectorExpirationDetails, SectorPlottingDetails,
+};
 use crate::thread_pool_manager::PlottingThreadPoolManager;
 use crate::utils::{tokio_rayon_spawn_handler, AsyncJoinOnDrop};
 use crate::KNOWN_PEERS_CACHE_SIZE;
@@ -2375,9 +2346,6 @@ 
Files

     /// Failed to decode metadata header
     #[error("Failed to decode metadata header: {0}")]
     FailedToDecodeMetadataHeader(parity_scale_codec::Error),
-    /// Failed to decode sector metadata
-    #[error("Failed to decode sector metadata: {0}")]
-    FailedToDecodeSectorMetadata(parity_scale_codec::Error),
     /// Unexpected metadata version
     #[error("Unexpected metadata version {0}")]
     UnexpectedMetadataVersion(u8),
@@ -2554,59 +2522,10 @@ 
Files

 type HandlerFn<A> = Arc<dyn Fn(&A) + Send + Sync + 'static>;
 type Handler<A> = Bag<HandlerFn<A>, A>;
 
-/// Details about sector currently being plotted
-#[derive(Debug, Clone, Encode, Decode)]
-pub enum SectorPlottingDetails {
-    /// Starting plotting of a sector
-    Starting {
-        /// Progress so far in % (not including this sector)
-        progress: f32,
-        /// Whether sector is being replotted
-        replotting: bool,
-        /// Whether this is the last sector queued so far
-        last_queued: bool,
-    },
-    /// Downloading sector pieces
-    Downloading,
-    /// Downloaded sector pieces
-    Downloaded(Duration),
-    /// Encoding sector pieces
-    Encoding,
-    /// Encoded sector pieces
-    Encoded(Duration),
-    /// Writing sector
-    Writing,
-    /// Wrote sector
-    Wrote(Duration),
-    /// Finished plotting
-    Finished {
-        /// Information about plotted sector
-        plotted_sector: PlottedSector,
-        /// Information about old plotted sector that was replaced
-        old_plotted_sector: Option<PlottedSector>,
-        /// How much time it took to plot a sector
-        time: Duration,
-    },
-}
-
-/// Details about sector expiration
-#[derive(Debug, Clone, Encode, Decode)]
-pub enum SectorExpirationDetails {
-    /// Sector expiration became known
-    Determined {
-        /// Segment index at which sector expires
-        expires_at: SegmentIndex,
-    },
-    /// Sector will expire at the next segment index and should be replotted
-    AboutToExpire,
-    /// Sector already expired
-    Expired,
-}
-
 /// Various sector updates
 #[derive(Debug, Clone, Encode, Decode)]
 pub enum SectorUpdate {
-    /// Sector is is being plotted
+    /// Sector is being plotted
     Plotting(SectorPlottingDetails),
     /// Sector expiration information updated
     Expiration(SectorExpirationDetails),
@@ -2615,8 +2534,8 @@ 
Files

 #[derive(Default, Debug)]
 struct Handlers {
     sector_update: Handler<(SectorIndex, SectorUpdate)>,
+    farming_notification: Handler<FarmingNotification>,
     solution: Handler<SolutionResponse>,
-    plot_audited: Handler<AuditEvent>,
 }
 
 /// Single disk farm abstraction is a container for everything necessary to plot/farm with a single
@@ -2763,7 +2682,6 @@ 
Files

                 single_disk_farm_info
             }
         };
-        let farm_id = *single_disk_farm_info.id();
 
         let single_disk_farm_info_lock = SingleDiskFarmInfo::try_lock(&directory)
             .map_err(SingleDiskFarmError::LikelyAlreadyInUse)?;
@@ -2829,12 +2747,13 @@ 
Files

             }
         };
 
+        let metadata_file_path = directory.join(Self::METADATA_FILE);
         let mut metadata_file = OpenOptions::new()
             .read(true)
             .write(true)
             .create(true)
             .advise_random_access()
-            .open(directory.join(Self::METADATA_FILE))?;
+            .open(&metadata_file_path)?;
 
         metadata_file.advise_random_access()?;
 
@@ -2891,14 +2810,34 @@ 
Files

 
             let mut sector_metadata_bytes = vec![0; sector_metadata_size];
             for sector_index in 0..metadata_header.plotted_sector_count {
-                metadata_file.read_exact_at(
-                    &mut sector_metadata_bytes,
-                    RESERVED_PLOT_METADATA + sector_metadata_size as u64 * u64::from(sector_index),
-                )?;
-                sectors_metadata.push(
-                    SectorMetadataChecksummed::decode(&mut sector_metadata_bytes.as_ref())
-                        .map_err(SingleDiskFarmError::FailedToDecodeSectorMetadata)?,
-                );
+                let sector_offset =
+                    RESERVED_PLOT_METADATA + sector_metadata_size as u64 * u64::from(sector_index);
+                metadata_file.read_exact_at(&mut sector_metadata_bytes, sector_offset)?;
+
+                let sector_metadata =
+                    match SectorMetadataChecksummed::decode(&mut sector_metadata_bytes.as_ref()) {
+                        Ok(sector_metadata) => sector_metadata,
+                        Err(error) => {
+                            warn!(
+                                path = %metadata_file_path.display(),
+                                %error,
+                                %sector_index,
+                                "Failed to decode sector metadata, replacing with dummy expired \
+                                sector metadata"
+                            );
+
+                            let dummy_sector = SectorMetadataChecksummed::from(SectorMetadata {
+                                sector_index,
+                                pieces_in_sector,
+                                s_bucket_sizes: Box::new([0; Record::NUM_S_BUCKETS]),
+                                history_size: HistorySize::from(SegmentIndex::ZERO),
+                            });
+                            metadata_file.write_all_at(&dummy_sector.encode(), sector_offset)?;
+
+                            dummy_sector
+                        }
+                    };
+                sectors_metadata.push(sector_metadata);
             }
 
             Arc::new(RwLock::new(sectors_metadata))
@@ -3132,7 +3071,6 @@ 
Files

                             handlers,
                             modifying_sector_index,
                             slot_info_notifications: slot_info_forwarder_receiver,
-                            farm_id,
                         };
                         farming::<PosTable, _, _>(farming_options).await
                     };
@@ -3383,9 +3321,9 @@ 
Files

         self.handlers.sector_update.add(callback)
     }
 
-    /// Subscribe to notification about audited plots
-    pub fn on_plot_audited(&self, callback: HandlerFn<AuditEvent>) -> HandlerId {
-        self.handlers.plot_audited.add(callback)
+    /// Subscribe to farming notifications
+    pub fn on_farming_notification(&self, callback: HandlerFn<FarmingNotification>) -> HandlerId {
+        self.handlers.farming_notification.add(callback)
     }
 
     /// Subscribe to new solution notification
diff --git a/src/subspace_farmer/single_disk_farm/farming.rs.html b/src/subspace_farmer/single_disk_farm/farming.rs.html
index 77d1a33146..47d66f0d5d 100644
--- a/src/subspace_farmer/single_disk_farm/farming.rs.html
+++ b/src/subspace_farmer/single_disk_farm/farming.rs.html
@@ -341,39 +341,247 @@ 
Files

 339
 340
 341
+342
+343
+344
+345
+346
+347
+348
+349
+350
+351
+352
+353
+354
+355
+356
+357
+358
+359
+360
+361
+362
+363
+364
+365
+366
+367
+368
+369
+370
+371
+372
+373
+374
+375
+376
+377
+378
+379
+380
+381
+382
+383
+384
+385
+386
+387
+388
+389
+390
+391
+392
+393
+394
+395
+396
+397
+398
+399
+400
+401
+402
+403
+404
+405
+406
+407
+408
+409
+410
+411
+412
+413
+414
+415
+416
+417
+418
+419
+420
+421
+422
+423
+424
+425
+426
+427
+428
+429
+430
+431
+432
+433
+434
+435
+436
+437
+438
+439
+440
+441
+442
+443
+444
+445
+446
+447
+448
+449
+450
+451
+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
+480
+481
+482
+483
+484
+485
+486
+487
+488
+489
+490
+491
+492
 
pub mod rayon_files;
 
 use crate::node_client;
 use crate::node_client::NodeClient;
-use crate::single_disk_farm::{Handlers, SingleDiskFarmId};
+use crate::single_disk_farm::Handlers;
 use async_lock::RwLock;
 use futures::channel::mpsc;
 use futures::StreamExt;
+use parity_scale_codec::{Decode, Encode, Error, Input, Output};
 use parking_lot::Mutex;
 use rayon::ThreadPoolBuildError;
-use std::io;
 use std::sync::Arc;
-use std::time::Instant;
+use std::time::{Duration, Instant};
+use std::{fmt, io};
 use subspace_core_primitives::crypto::kzg::Kzg;
 use subspace_core_primitives::{PosSeed, PublicKey, SectorIndex, Solution, SolutionRange};
 use subspace_erasure_coding::ErasureCoding;
-use subspace_farmer_components::auditing::audit_plot_sync;
+use subspace_farmer_components::auditing::{audit_plot_sync, AuditingError};
 use subspace_farmer_components::proving::{ProvableSolutions, ProvingError};
 use subspace_farmer_components::sector::SectorMetadataChecksummed;
-use subspace_farmer_components::{proving, ReadAtSync};
+use subspace_farmer_components::ReadAtSync;
 use subspace_proof_of_space::{Table, TableGenerator};
 use subspace_rpc_primitives::{SlotInfo, SolutionResponse};
 use thiserror::Error;
 use tracing::{debug, error, info, trace, warn};
 
-#[derive(Debug, Clone)]
-pub struct AuditEvent {
-    /// Defines how much time took the audit in secs
-    pub duration: f64,
-    /// ID of the farm
-    pub farm_id: SingleDiskFarmId,
-    /// Number of sectors for this audit
-    pub sectors_number: usize,
+/// Auditing details
+#[derive(Debug, Copy, Clone, Encode, Decode)]
+pub struct AuditingDetails {
+    /// Number of sectors that were audited
+    pub sectors_count: SectorIndex,
+    /// Audit duration
+    pub time: Duration,
+}
+
+/// Result of the proving
+#[derive(Debug, Copy, Clone, Encode, Decode)]
+pub enum ProvingResult {
+    /// Proved successfully and accepted by the node
+    Success,
+    /// Proving took too long
+    Timeout,
+    /// Managed to prove within time limit, but node rejected solution, likely due to timeout on its
+    /// end
+    Rejected,
+}
+
+impl fmt::Display for ProvingResult {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            ProvingResult::Success => "Success",
+            ProvingResult::Timeout => "Timeout",
+            ProvingResult::Rejected => "Rejected",
+        })
+    }
+}
+
+/// Proving details
+#[derive(Debug, Copy, Clone, Encode, Decode)]
+pub struct ProvingDetails {
+    /// Whether proving ended up being successful
+    pub result: ProvingResult,
+    /// Audit duration
+    pub time: Duration,
+}
+
+/// Various farming notifications
+#[derive(Debug, Clone, Encode, Decode)]
+pub enum FarmingNotification {
+    /// Auditing
+    Auditing(AuditingDetails),
+    /// Proving
+    Proving(ProvingDetails),
+    /// Non-fatal farming error
+    NonFatalError(Arc<FarmingError>),
+}
+
+/// Special decoded farming error
+#[derive(Debug, Encode, Decode)]
+pub struct DecodedFarmingError {
+    /// String representation of an error
+    error: String,
+    /// Whether error is fatal
+    is_fatal: bool,
+}
+
+impl fmt::Display for DecodedFarmingError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.error.fmt(f)
+    }
 }
 
 /// Errors that happen during farming
@@ -391,15 +599,66 @@ 
Files

         /// Lower-level error
         error: node_client::Error,
     },
+    /// Low-level auditing error
+    #[error("Low-level auditing error: {0}")]
+    LowLevelAuditing(#[from] AuditingError),
     /// Low-level proving error
     #[error("Low-level proving error: {0}")]
-    LowLevelProving(#[from] proving::ProvingError),
+    LowLevelProving(#[from] ProvingError),
     /// I/O error occurred
     #[error("I/O error: {0}")]
     Io(#[from] io::Error),
     /// Failed to create thread pool
     #[error("Failed to create thread pool: {0}")]
     FailedToCreateThreadPool(#[from] ThreadPoolBuildError),
+    /// Decoded farming error
+    #[error("Decoded farming error {0}")]
+    Decoded(DecodedFarmingError),
+}
+
+impl Encode for FarmingError {
+    fn encode_to<O: Output + ?Sized>(&self, dest: &mut O) {
+        let error = DecodedFarmingError {
+            error: self.to_string(),
+            is_fatal: self.is_fatal(),
+        };
+
+        error.encode_to(dest)
+    }
+}
+
+impl Decode for FarmingError {
+    fn decode<I: Input>(input: &mut I) -> Result<Self, Error> {
+        DecodedFarmingError::decode(input).map(FarmingError::Decoded)
+    }
+}
+
+impl FarmingError {
+    /// String variant of the error, primarily for monitoring purposes
+    pub fn str_variant(&self) -> &str {
+        match self {
+            FarmingError::FailedToSubscribeSlotInfo { .. } => "FailedToSubscribeSlotInfo",
+            FarmingError::FailedToGetFarmerInfo { .. } => "FailedToGetFarmerInfo",
+            FarmingError::LowLevelAuditing(_) => "LowLevelAuditing",
+            FarmingError::LowLevelProving(_) => "LowLevelProving",
+            FarmingError::Io(_) => "Io",
+            FarmingError::FailedToCreateThreadPool(_) => "FailedToCreateThreadPool",
+            FarmingError::Decoded(_) => "Decoded",
+        }
+    }
+
+    /// Whether this error is fatal and makes farm unusable
+    pub fn is_fatal(&self) -> bool {
+        match self {
+            FarmingError::FailedToSubscribeSlotInfo { .. } => true,
+            FarmingError::FailedToGetFarmerInfo { .. } => true,
+            FarmingError::LowLevelAuditing(_) => true,
+            FarmingError::LowLevelProving(error) => error.is_fatal(),
+            FarmingError::Io(_) => true,
+            FarmingError::FailedToCreateThreadPool(_) => true,
+            FarmingError::Decoded(error) => error.is_fatal,
+        }
+    }
 }
 
 pub(super) async fn slot_notification_forwarder<NC>(
@@ -484,10 +743,13 @@ 
Files

     pub fn audit<PosTable>(
         &'a self,
         options: PlotAuditOptions<'a, PosTable>,
-    ) -> Vec<(
-        SectorIndex,
-        impl ProvableSolutions<Item = Result<Solution<PublicKey, PublicKey>, ProvingError>> + 'a,
-    )>
+    ) -> Result<
+        Vec<(
+            SectorIndex,
+            impl ProvableSolutions<Item = Result<Solution<PublicKey, PublicKey>, ProvingError>> + 'a,
+        )>,
+        AuditingError,
+    >
     where
         PosTable: Table,
     {
@@ -509,9 +771,9 @@ 
Files

             &self.0,
             sectors_metadata,
             maybe_sector_being_modified,
-        );
+        )?;
 
-        audit_results
+        Ok(audit_results
             .into_iter()
             .filter_map(|audit_results| {
                 let sector_index = audit_results.sector_index;
@@ -542,7 +804,7 @@ 
Files

 
                 Some((sector_index, sector_solutions))
             })
-            .collect()
+            .collect())
     }
 }
 
@@ -557,7 +819,6 @@ 
Files

     pub(super) handlers: Arc<Handlers>,
     pub(super) modifying_sector_index: Arc<RwLock<Option<SectorIndex>>>,
     pub(super) slot_info_notifications: mpsc::Receiver<SlotInfo>,
-    pub(super) farm_id: SingleDiskFarmId,
 }
 
 /// Starts farming process.
@@ -583,7 +844,6 @@ 
Files

         handlers,
         modifying_sector_index,
         mut slot_info_notifications,
-        farm_id,
     } = farming_options;
 
     let farmer_app_info = node_client
@@ -597,86 +857,128 @@ 
Files

     let table_generator = Arc::new(Mutex::new(PosTable::generator()));
 
     while let Some(slot_info) = slot_info_notifications.next().await {
-        let start = Instant::now();
-        let slot = slot_info.slot_number;
-        let sectors_metadata = sectors_metadata.read().await;
-
-        debug!(%slot, sector_count = %sectors_metadata.len(), "Reading sectors");
-
-        let mut sectors_solutions = {
-            let modifying_sector_guard = modifying_sector_index.read().await;
-            let maybe_sector_being_modified = modifying_sector_guard.as_ref().copied();
-
+        let result: Result<(), FarmingError> = try {
             let start = Instant::now();
-
-            let sectors_solutions = plot_audit.audit(PlotAuditOptions::<PosTable> {
-                public_key: &public_key,
-                reward_address: &reward_address,
-                slot_info,
-                sectors_metadata: &sectors_metadata,
-                kzg: &kzg,
-                erasure_coding: &erasure_coding,
-                maybe_sector_being_modified,
-                table_generator: &table_generator,
-            });
-
-            handlers.plot_audited.call_simple(&AuditEvent {
-                duration: start.elapsed().as_secs_f64(),
-                farm_id,
-                sectors_number: sectors_metadata.len(),
+            let slot = slot_info.slot_number;
+            let sectors_metadata = sectors_metadata.read().await;
+
+            debug!(%slot, sector_count = %sectors_metadata.len(), "Reading sectors");
+
+            let mut sectors_solutions = {
+                let modifying_sector_guard = modifying_sector_index.read().await;
+                let maybe_sector_being_modified = modifying_sector_guard.as_ref().copied();
+
+                plot_audit.audit(PlotAuditOptions::<PosTable> {
+                    public_key: &public_key,
+                    reward_address: &reward_address,
+                    slot_info,
+                    sectors_metadata: &sectors_metadata,
+                    kzg: &kzg,
+                    erasure_coding: &erasure_coding,
+                    maybe_sector_being_modified,
+                    table_generator: &table_generator,
+                })?
+            };
+
+            sectors_solutions.sort_by(|a, b| {
+                let a_solution_distance =
+                    a.1.best_solution_distance().unwrap_or(SolutionRange::MAX);
+                let b_solution_distance =
+                    b.1.best_solution_distance().unwrap_or(SolutionRange::MAX);
+
+                a_solution_distance.cmp(&b_solution_distance)
             });
 
-            sectors_solutions
-        };
-
-        sectors_solutions.sort_by(|a, b| {
-            let a_solution_distance = a.1.best_solution_distance().unwrap_or(SolutionRange::MAX);
-            let b_solution_distance = b.1.best_solution_distance().unwrap_or(SolutionRange::MAX);
+            handlers
+                .farming_notification
+                .call_simple(&FarmingNotification::Auditing(AuditingDetails {
+                    sectors_count: sectors_metadata.len() as SectorIndex,
+                    time: start.elapsed(),
+                }));
 
-            a_solution_distance.cmp(&b_solution_distance)
-        });
+            'solutions_processing: for (sector_index, sector_solutions) in sectors_solutions {
+                if sector_solutions.is_empty() {
+                    continue;
+                }
+                let mut start = Instant::now();
+                for maybe_solution in sector_solutions {
+                    let solution = match maybe_solution {
+                        Ok(solution) => solution,
+                        Err(error) => {
+                            error!(%slot, %sector_index, %error, "Failed to prove");
+                            // Do not error completely as disk corruption or other reasons why
+                            // proving might fail
+                            start = Instant::now();
+                            continue;
+                        }
+                    };
+
+                    debug!(%slot, %sector_index, "Solution found");
+                    trace!(?solution, "Solution found");
+
+                    if start.elapsed() >= farming_timeout {
+                        handlers
+                            .farming_notification
+                            .call_simple(&FarmingNotification::Proving(ProvingDetails {
+                                result: ProvingResult::Timeout,
+                                time: start.elapsed(),
+                            }));
+                        warn!(
+                            %slot,
+                            %sector_index,
+                            "Proving for solution skipped due to farming time limit",
+                        );
 
-        'solutions_processing: for (sector_index, sector_solutions) in sectors_solutions {
-            for maybe_solution in sector_solutions {
-                let solution = match maybe_solution {
-                    Ok(solution) => solution,
-                    Err(error) => {
-                        error!(%slot, %sector_index, %error, "Failed to prove");
-                        // Do not error completely as disk corruption or other reasons why
-                        // proving might fail
-                        continue;
+                        break 'solutions_processing;
                     }
-                };
 
-                debug!(%slot, %sector_index, "Solution found");
-                trace!(?solution, "Solution found");
+                    let response = SolutionResponse {
+                        slot_number: slot,
+                        solution,
+                    };
 
-                if start.elapsed() >= farming_timeout {
-                    warn!(
-                        %slot,
-                        %sector_index,
-                        "Proving for solution skipped due to farming time limit",
-                    );
-                    break 'solutions_processing;
-                }
+                    handlers.solution.call_simple(&response);
 
-                let response = SolutionResponse {
-                    slot_number: slot,
-                    solution,
-                };
-
-                handlers.solution.call_simple(&response);
+                    if let Err(error) = node_client.submit_solution_response(response).await {
+                        handlers
+                            .farming_notification
+                            .call_simple(&FarmingNotification::Proving(ProvingDetails {
+                                result: ProvingResult::Rejected,
+                                time: start.elapsed(),
+                            }));
+                        warn!(
+                            %slot,
+                            %sector_index,
+                            %error,
+                            "Failed to send solution to node, skipping further proving for this slot",
+                        );
+                        break 'solutions_processing;
+                    }
 
-                if let Err(error) = node_client.submit_solution_response(response).await {
-                    warn!(
-                        %slot,
-                        %sector_index,
-                        %error,
-                        "Failed to send solution to node, skipping further proving for this slot",
-                    );
-                    break 'solutions_processing;
+                    handlers
+                        .farming_notification
+                        .call_simple(&FarmingNotification::Proving(ProvingDetails {
+                            result: ProvingResult::Success,
+                            time: start.elapsed(),
+                        }));
+                    start = Instant::now();
                 }
             }
+        };
+
+        if let Err(error) = result {
+            if error.is_fatal() {
+                return Err(error);
+            } else {
+                warn!(
+                    %error,
+                    "Non-fatal farming error"
+                );
+
+                handlers
+                    .farming_notification
+                    .call_simple(&FarmingNotification::NonFatalError(Arc::new(error)));
+            }
         }
     }
 
diff --git a/src/subspace_farmer/single_disk_farm/plotting.rs.html b/src/subspace_farmer/single_disk_farm/plotting.rs.html
index 08f8c6f844..8fb0768f88 100644
--- a/src/subspace_farmer/single_disk_farm/plotting.rs.html
+++ b/src/subspace_farmer/single_disk_farm/plotting.rs.html
@@ -933,9 +933,56 @@ 
Files

 931
 932
 933
+934
+935
+936
+937
+938
+939
+940
+941
+942
+943
+944
+945
+946
+947
+948
+949
+950
+951
+952
+953
+954
+955
+956
+957
+958
+959
+960
+961
+962
+963
+964
+965
+966
+967
+968
+969
+970
+971
+972
+973
+974
+975
+976
+977
+978
+979
+980
+981
 
use crate::single_disk_farm::{
-    BackgroundTaskError, Handlers, PlotMetadataHeader, SectorExpirationDetails,
-    SectorPlottingDetails, SectorUpdate, RESERVED_PLOT_METADATA,
+    BackgroundTaskError, Handlers, PlotMetadataHeader, SectorUpdate, RESERVED_PLOT_METADATA,
 };
 use crate::thread_pool_manager::PlottingThreadPoolManager;
 use crate::utils::AsyncJoinOnDrop;
@@ -945,7 +992,7 @@ 
Files

 use futures::channel::{mpsc, oneshot};
 use futures::{select, FutureExt, SinkExt, StreamExt};
 use lru::LruCache;
-use parity_scale_codec::Encode;
+use parity_scale_codec::{Decode, Encode};
 use std::collections::HashMap;
 use std::fs::File;
 use std::io;
@@ -981,6 +1028,55 @@ 
Files

 /// Get piece retry attempts number.
 const PIECE_GETTER_RETRY_NUMBER: NonZeroU16 = NonZeroU16::new(4).expect("Not zero; qed");
 
+/// Details about sector currently being plotted
+#[derive(Debug, Clone, Encode, Decode)]
+pub enum SectorPlottingDetails {
+    /// Starting plotting of a sector
+    Starting {
+        /// Progress so far in % (not including this sector)
+        progress: f32,
+        /// Whether sector is being replotted
+        replotting: bool,
+        /// Whether this is the last sector queued so far
+        last_queued: bool,
+    },
+    /// Downloading sector pieces
+    Downloading,
+    /// Downloaded sector pieces
+    Downloaded(Duration),
+    /// Encoding sector pieces
+    Encoding,
+    /// Encoded sector pieces
+    Encoded(Duration),
+    /// Writing sector
+    Writing,
+    /// Written sector
+    Written(Duration),
+    /// Finished plotting
+    Finished {
+        /// Information about plotted sector
+        plotted_sector: PlottedSector,
+        /// Information about old plotted sector that was replaced
+        old_plotted_sector: Option<PlottedSector>,
+        /// How much time it took to plot a sector
+        time: Duration,
+    },
+}
+
+/// Details about sector expiration
+#[derive(Debug, Clone, Encode, Decode)]
+pub enum SectorExpirationDetails {
+    /// Sector expiration became known
+    Determined {
+        /// Segment index at which sector expires
+        expires_at: SegmentIndex,
+    },
+    /// Sector will expire at the next segment index and should be replotted
+    AboutToExpire,
+    /// Sector already expired
+    Expired,
+}
+
 pub(super) struct SectorToPlot {
     sector_index: SectorIndex,
     /// Progress so far in % (not including this sector)
@@ -1337,7 +1433,7 @@ 
Files

 
             handlers.sector_update.call_simple(&(
                 sector_index,
-                SectorUpdate::Plotting(SectorPlottingDetails::Wrote(start.elapsed())),
+                SectorUpdate::Plotting(SectorPlottingDetails::Written(start.elapsed())),
             ));
         }
 
diff --git a/src/subspace_farmer_components/auditing.rs.html b/src/subspace_farmer_components/auditing.rs.html
index 823f283d9b..d77d005141 100644
--- a/src/subspace_farmer_components/auditing.rs.html
+++ b/src/subspace_farmer_components/auditing.rs.html
@@ -253,16 +253,43 @@ 
Files

 251
 252
 253
+254
+255
+256
+257
+258
+259
+260
+261
+262
+263
+264
 
use crate::proving::SolutionCandidates;
 use crate::sector::{sector_size, SectorContentsMap, SectorMetadataChecksummed};
 use crate::{ReadAtOffset, ReadAtSync};
 use rayon::prelude::*;
+use std::io;
 use subspace_core_primitives::crypto::Scalar;
 use subspace_core_primitives::{
     Blake3Hash, PublicKey, SBucket, SectorId, SectorIndex, SectorSlotChallenge, SolutionRange,
 };
 use subspace_verification::is_within_solution_range;
-use tracing::warn;
+use thiserror::Error;
+
+/// Errors that happen during proving
+#[derive(Debug, Error)]
+pub enum AuditingError {
+    /// Failed read s-bucket
+    #[error("Failed read s-bucket {s_bucket_audit_index} of sector {sector_index}: {error}")]
+    SBucketReading {
+        /// Sector index
+        sector_index: SectorIndex,
+        /// S-bucket audit index
+        s_bucket_audit_index: SBucket,
+        /// Low-level error
+        error: io::Error,
+    },
+}
 
 /// Result of sector audit
 #[derive(Debug, Clone)]
@@ -297,7 +324,7 @@ 
Files

     solution_range: SolutionRange,
     sector: Sector,
     sector_metadata: &'a SectorMetadataChecksummed,
-) -> Option<AuditResult<'a, Sector>>
+) -> Result<Option<AuditResult<'a, Sector>>, AuditingError>
 where
     Sector: ReadAtSync + 'a,
 {
@@ -310,26 +337,24 @@ 
Files

     } = collect_sector_auditing_details(public_key.hash(), global_challenge, sector_metadata);
 
     let mut s_bucket = vec![0; s_bucket_audit_size];
-    let read_s_bucket_result = sector.read_at(&mut s_bucket, s_bucket_audit_offset_in_sector);
-
-    if let Err(error) = read_s_bucket_result {
-        warn!(
-            %error,
-            sector_index = %sector_metadata.sector_index,
-            %s_bucket_audit_index,
-            "Failed read s-bucket",
-        );
-        return None;
-    }
+    sector
+        .read_at(&mut s_bucket, s_bucket_audit_offset_in_sector)
+        .map_err(|error| AuditingError::SBucketReading {
+            sector_index: sector_metadata.sector_index,
+            s_bucket_audit_index,
+            error,
+        })?;
 
-    let (winning_chunks, best_solution_distance) = map_winning_chunks(
+    let Some((winning_chunks, best_solution_distance)) = map_winning_chunks(
         &s_bucket,
         global_challenge,
         &sector_slot_challenge,
         solution_range,
-    )?;
+    ) else {
+        return Ok(None);
+    };
 
-    Some(AuditResult {
+    Ok(Some(AuditResult {
         sector_index: sector_metadata.sector_index,
         solution_candidates: SolutionCandidates::new(
             public_key,
@@ -340,7 +365,7 @@ 
Files

             winning_chunks.into(),
         ),
         best_solution_distance,
-    })
+    }))
 }
 
 /// Audit the whole plot and generate streams of solutions
@@ -351,7 +376,7 @@ 
Files

     plot: &'a Plot,
     sectors_metadata: &'a [SectorMetadataChecksummed],
     maybe_sector_being_modified: Option<SectorIndex>,
-) -> Vec<AuditResult<'a, ReadAtOffset<'a, Plot>>>
+) -> Result<Vec<AuditResult<'a, ReadAtOffset<'a, Plot>>>, AuditingError>
 where
     Plot: ReadAtSync + 'a,
 {
@@ -390,14 +415,11 @@ 
Files

                 &mut s_bucket,
                 sector_auditing_info.s_bucket_audit_offset_in_sector,
             ) {
-                warn!(
-                    %error,
-                    sector_index = %sector_metadata.sector_index,
-                    s_bucket_audit_index = %sector_auditing_info.s_bucket_audit_index,
-                    "Failed read s-bucket",
-                );
-
-                return None;
+                return Some(Err(AuditingError::SBucketReading {
+                    sector_index: sector_metadata.sector_index,
+                    s_bucket_audit_index: sector_auditing_info.s_bucket_audit_index,
+                    error,
+                }));
             }
 
             let (winning_chunks, best_solution_distance) = map_winning_chunks(
@@ -407,7 +429,7 @@ 
Files

                 solution_range,
             )?;
 
-            Some(AuditResult {
+            Some(Ok(AuditResult {
                 sector_index: sector_metadata.sector_index,
                 solution_candidates: SolutionCandidates::new(
                     public_key,
@@ -418,7 +440,7 @@ 
Files

                     winning_chunks.into(),
                 ),
                 best_solution_distance,
-            })
+            }))
         })
         .collect()
 }
diff --git a/src/subspace_farmer_components/proving.rs.html b/src/subspace_farmer_components/proving.rs.html
index 7ff2e7c29f..5867278d87 100644
--- a/src/subspace_farmer_components/proving.rs.html
+++ b/src/subspace_farmer_components/proving.rs.html
@@ -397,6 +397,20 @@ 
Files

 395
 396
 397
+398
+399
+400
+401
+402
+403
+404
+405
+406
+407
+408
+409
+410
+411
 
use crate::auditing::ChunkCandidate;
 use crate::reading::{read_record_metadata, read_sector_record_chunks, ReadingError};
 use crate::sector::{
@@ -459,6 +473,20 @@ 
Files

     RecordReadingError(#[from] ReadingError),
 }
 
+impl ProvingError {
+    /// Whether this error is fatal and makes farm unusable
+    pub fn is_fatal(&self) -> bool {
+        match self {
+            ProvingError::InvalidErasureCodingInstance => true,
+            ProvingError::FailedToCreatePolynomialForRecord { .. } => false,
+            ProvingError::FailedToCreateChunkWitness { .. } => false,
+            ProvingError::FailedToDecodeSectorContentsMap(_) => false,
+            ProvingError::Io(_) => true,
+            ProvingError::RecordReadingError(error) => error.is_fatal(),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 struct WinningChunk {
     /// Chunk offset within s-bucket
diff --git a/src/subspace_farmer_components/reading.rs.html b/src/subspace_farmer_components/reading.rs.html
index b33bc0203a..399a931690 100644
--- a/src/subspace_farmer_components/reading.rs.html
+++ b/src/subspace_farmer_components/reading.rs.html
@@ -411,6 +411,21 @@ 
Files

 409
 410
 411
+412
+413
+414
+415
+416
+417
+418
+419
+420
+421
+422
+423
+424
+425
+426
 
use crate::sector::{
     sector_record_chunks_size, RecordMetadata, SectorContentsMap, SectorContentsMapFromBytesError,
     SectorMetadataChecksummed,
@@ -488,6 +503,21 @@ 
Files

     ChecksumMismatch,
 }
 
+impl ReadingError {
+    /// Whether this error is fatal and renders farm unusable
+    pub fn is_fatal(&self) -> bool {
+        match self {
+            ReadingError::FailedToReadChunk { .. } => false,
+            ReadingError::InvalidChunk { .. } => false,
+            ReadingError::FailedToErasureDecodeRecord { .. } => false,
+            ReadingError::WrongRecordSizeAfterDecoding { .. } => false,
+            ReadingError::FailedToDecodeSectorContentsMap(_) => false,
+            ReadingError::Io(_) => true,
+            ReadingError::ChecksumMismatch => false,
+        }
+    }
+}
+
 /// Record contained in the plot
 #[derive(Debug, Clone)]
 pub struct PlotRecord {
diff --git a/src/subspace_test_client/lib.rs.html b/src/subspace_test_client/lib.rs.html
index 855b0af4e4..63d918d4f7 100644
--- a/src/subspace_test_client/lib.rs.html
+++ b/src/subspace_test_client/lib.rs.html
@@ -254,6 +254,7 @@ 
Files

 252
 253
 254
+255
 
// Copyright (C) 2021 Subspace Labs, Inc.
 // SPDX-License-Identifier: GPL-3.0-or-later
 
@@ -428,6 +429,7 @@ 
Files

             );
 
             let solution = audit_result
+                .unwrap()
                 .unwrap()
                 .solution_candidates
                 .into_solutions(&public_key, &kzg, &erasure_coding, |seed: &PosSeed| {
diff --git a/subspace_farmer/all.html b/subspace_farmer/all.html
index 9cc8ee7ffa..194a4cc45b 100644
--- a/subspace_farmer/all.html
+++ b/subspace_farmer/all.html
@@ -1,2 +1,2 @@
 List of all items in this crate

-    
List of all items
Structs
Enums
Traits
Functions
Type Aliases
Constants

\ No newline at end of file
+    
List of all items
Structs
Enums
Traits
Functions
Type Aliases
Constants

\ No newline at end of file
diff --git a/subspace_farmer/constant.KNOWN_PEERS_CACHE_SIZE.html b/subspace_farmer/constant.KNOWN_PEERS_CACHE_SIZE.html
index 011c947907..c950ab25fd 100644
--- a/subspace_farmer/constant.KNOWN_PEERS_CACHE_SIZE.html
+++ b/subspace_farmer/constant.KNOWN_PEERS_CACHE_SIZE.html
@@ -1,3 +1,3 @@
 KNOWN_PEERS_CACHE_SIZE in subspace_farmer - Rust

-    
Constant subspace_farmer::KNOWN_PEERS_CACHE_SIZE
source · 
pub const KNOWN_PEERS_CACHE_SIZE: NonZeroUsize;
Expand description
Size of the LRU cache for peers.

+    
Constant subspace_farmer::KNOWN_PEERS_CACHE_SIZE
source · 
pub const KNOWN_PEERS_CACHE_SIZE: NonZeroUsize;
Expand description
Size of the LRU cache for peers.

 

\ No newline at end of file
diff --git a/subspace_farmer/index.html b/subspace_farmer/index.html
index 3a6413df75..5cc3c54612 100644
--- a/subspace_farmer/index.html
+++ b/subspace_farmer/index.html
@@ -1,6 +1,6 @@
 subspace_farmer - Rust

-    
Crate subspace_farmer
source · 
Expand description
subspace-farmer library implementation overview

+    
Crate subspace_farmer
source · 
Expand description
subspace-farmer library implementation overview

 
This library provides droppable/interruptable instances of two processes that can be run in
 parallel: plotting and farming.

 
During plotting we create:

diff --git a/subspace_farmer/single_disk_farm/enum.BackgroundTaskError.html b/subspace_farmer/single_disk_farm/enum.BackgroundTaskError.html
index 5aeafd63f0..8e5f4dcdea 100644
--- a/subspace_farmer/single_disk_farm/enum.BackgroundTaskError.html
+++ b/subspace_farmer/single_disk_farm/enum.BackgroundTaskError.html
@@ -1,5 +1,5 @@
 BackgroundTaskError in subspace_farmer::single_disk_farm - Rust

-    
Enum subspace_farmer::single_disk_farm::BackgroundTaskError
source · 
pub enum BackgroundTaskError {
+    
Enum subspace_farmer::single_disk_farm::BackgroundTaskError
source · 
pub enum BackgroundTaskError {
     Plotting(PlottingError),
     Farming(FarmingError),
     RewardSigning(Box<dyn Error + Send + Sync + 'static>),
@@ -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§
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§
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 dabfaeced3..c871ebab9a 100644
--- a/subspace_farmer/single_disk_farm/enum.PlottingError.html
+++ b/subspace_farmer/single_disk_farm/enum.PlottingError.html
@@ -1,5 +1,5 @@
 PlottingError in subspace_farmer::single_disk_farm - Rust

-    
Enum subspace_farmer::single_disk_farm::PlottingError
source · 
pub enum PlottingError {
+    
Enum subspace_farmer::single_disk_farm::PlottingError
source · 
pub enum PlottingError {
     FailedToGetFarmerInfo {
         error: Error,
     },
@@ -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§
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§
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.SectorExpirationDetails.html b/subspace_farmer/single_disk_farm/enum.SectorExpirationDetails.html
index a3acc04eeb..cbfa1a41a8 100644
--- a/subspace_farmer/single_disk_farm/enum.SectorExpirationDetails.html
+++ b/subspace_farmer/single_disk_farm/enum.SectorExpirationDetails.html
@@ -1,5 +1,5 @@
 SectorExpirationDetails in subspace_farmer::single_disk_farm - Rust

-    
Enum subspace_farmer::single_disk_farm::SectorExpirationDetails
source · 
pub enum SectorExpirationDetails {
+    
Enum subspace_farmer::single_disk_farm::SectorExpirationDetails
source · 
pub enum SectorExpirationDetails {
     Determined {
         expires_at: SegmentIndex,
     },
@@ -10,18 +10,18 @@
 
Sector expiration became known

 
§
AboutToExpire
Sector will expire at the next segment index and should be replotted

 
§
Expired
Sector already expired

-
Trait Implementations§
source§
impl Clone for SectorExpirationDetails
source§
fn clone(&self) -> SectorExpirationDetails
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 SectorExpirationDetails
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Decode for SectorExpirationDetails
source§
fn decode<__CodecInputEdqy: Input>(
+
Trait Implementations§
source§
impl Clone for SectorExpirationDetails
source§
fn clone(&self) -> SectorExpirationDetails
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 SectorExpirationDetails
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Decode for SectorExpirationDetails
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 Encode for SectorExpirationDetails
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 Encode for SectorExpirationDetails
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
-    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 EncodeLike for SectorExpirationDetails
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
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 EncodeLike for SectorExpirationDetails
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/enum.SectorPlottingDetails.html b/subspace_farmer/single_disk_farm/enum.SectorPlottingDetails.html
index d67755367c..1f38018fae 100644
--- a/subspace_farmer/single_disk_farm/enum.SectorPlottingDetails.html
+++ b/subspace_farmer/single_disk_farm/enum.SectorPlottingDetails.html
@@ -1,5 +1,5 @@
-SectorPlottingDetails in subspace_farmer::single_disk_farm - Rust

-    
Enum subspace_farmer::single_disk_farm::SectorPlottingDetails
source · 
pub enum SectorPlottingDetails {
+SectorPlottingDetails in subspace_farmer::single_disk_farm - Rust

+    
Enum subspace_farmer::single_disk_farm::SectorPlottingDetails
source · 
pub enum SectorPlottingDetails {
     Starting {
         progress: f32,
         replotting: bool,
@@ -10,7 +10,7 @@
     Encoding,
     Encoded(Duration),
     Writing,
-    Wrote(Duration),
+    Written(Duration),
     Finished {
         plotted_sector: PlottedSector,
         old_plotted_sector: Option<PlottedSector>,
@@ -26,23 +26,23 @@
 
§
Encoding
Encoding sector pieces

 
§
Encoded(Duration)
Encoded sector pieces

 
§
Writing
Writing sector

-
§
Wrote(Duration)
Wrote sector

+
§
Written(Duration)
Written sector

 
§
Finished
Fields
§plotted_sector: PlottedSector
Information about plotted sector

 
§old_plotted_sector: Option<PlottedSector>
Information about old plotted sector that was replaced

 
§time: Duration
How much time it took to plot a sector

 
Finished plotting

-
Trait Implementations§
source§
impl Clone for SectorPlottingDetails
source§
fn clone(&self) -> SectorPlottingDetails
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 SectorPlottingDetails
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Decode for SectorPlottingDetails
source§
fn decode<__CodecInputEdqy: Input>(
+
Trait Implementations§
source§
impl Clone for SectorPlottingDetails
source§
fn clone(&self) -> SectorPlottingDetails
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 SectorPlottingDetails
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Decode for SectorPlottingDetails
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 Encode for SectorPlottingDetails
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 Encode for SectorPlottingDetails
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
-    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 EncodeLike for SectorPlottingDetails
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
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 EncodeLike for SectorPlottingDetails
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/enum.SectorUpdate.html b/subspace_farmer/single_disk_farm/enum.SectorUpdate.html
index e96b854425..665ced1929 100644
--- a/subspace_farmer/single_disk_farm/enum.SectorUpdate.html
+++ b/subspace_farmer/single_disk_farm/enum.SectorUpdate.html
@@ -1,22 +1,22 @@
 SectorUpdate in subspace_farmer::single_disk_farm - Rust

-    
Enum subspace_farmer::single_disk_farm::SectorUpdate
source · 
pub enum SectorUpdate {
+    
Enum subspace_farmer::single_disk_farm::SectorUpdate
source · 
pub enum SectorUpdate {
     Plotting(SectorPlottingDetails),
     Expiration(SectorExpirationDetails),
 }
Expand description
Various sector updates

-
Variants§
§
Plotting(SectorPlottingDetails)
Sector is is being plotted

+
Variants§
§
Plotting(SectorPlottingDetails)
Sector is being plotted

 
§
Expiration(SectorExpirationDetails)
Sector expiration information updated

-
Trait Implementations§
source§
impl Clone for SectorUpdate
source§
fn clone(&self) -> SectorUpdate
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 SectorUpdate
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Decode for SectorUpdate
source§
fn decode<__CodecInputEdqy: Input>(
+
Trait Implementations§
source§
impl Clone for SectorUpdate
source§
fn clone(&self) -> SectorUpdate
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 SectorUpdate
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Decode for SectorUpdate
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 Encode for SectorUpdate
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 Encode for SectorUpdate
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
-    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 EncodeLike for SectorUpdate
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
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 EncodeLike for SectorUpdate
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/enum.SingleDiskFarmError.html b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmError.html
index 193c061f55..d557f9741c 100644
--- a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmError.html
+++ b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmError.html
@@ -1,6 +1,6 @@
-SingleDiskFarmError in subspace_farmer::single_disk_farm - Rust

-    
Enum subspace_farmer::single_disk_farm::SingleDiskFarmError
source · 
pub enum SingleDiskFarmError {
-
Show 14 variants    FailedToOpenIdentity(IdentityError),
+SingleDiskFarmError in subspace_farmer::single_disk_farm - Rust

+    
Enum subspace_farmer::single_disk_farm::SingleDiskFarmError
source · 
pub enum SingleDiskFarmError {
+
Show 13 variants    FailedToOpenIdentity(IdentityError),
     LikelyAlreadyInUse(Error),
     Io(Error),
     PieceCacheError(DiskPieceCacheError),
@@ -22,7 +22,6 @@
         initialized_with: u16,
     },
     FailedToDecodeMetadataHeader(Error),
-    FailedToDecodeSectorMetadata(Error),
     UnexpectedMetadataVersion(u8),
     InsufficientAllocatedSpace {
         min_space: u64,
@@ -54,13 +53,12 @@
 
§initialized_with: u16
Number of pieces in sector farm is initialized with

 
Invalid number pieces in sector

 
§
FailedToDecodeMetadataHeader(Error)
Failed to decode metadata header

-
§
FailedToDecodeSectorMetadata(Error)
Failed to decode sector metadata

 
§
UnexpectedMetadataVersion(u8)
Unexpected metadata version

 
§
InsufficientAllocatedSpace
Fields
§min_space: u64
Minimal allocated space

 
§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§
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§
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 b48db9b8fa..c1eaeda6bf 100644
--- a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmId.html
+++ b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmId.html
@@ -1,21 +1,21 @@
 SingleDiskFarmId in subspace_farmer::single_disk_farm - Rust

-    
Enum subspace_farmer::single_disk_farm::SingleDiskFarmId
source · 
pub enum SingleDiskFarmId {
+    
Enum subspace_farmer::single_disk_farm::SingleDiskFarmId
source · 
pub enum SingleDiskFarmId {
     Ulid(Ulid),
 }
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
+
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
     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,
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
     Self: Sized,
Compares and returns the minimum of two values. Read more
1.50.0 · source§
fn clamp(self, min: Self, max: Self) -> Self
where
-    Self: Sized + PartialOrd,
Restrict a value to a certain interval. Read more
source§
impl PartialEq for SingleDiskFarmId
source§
fn eq(&self, other: &SingleDiskFarmId) -> bool
This method tests for self and other values to be equal, and is used
+    Self: Sized + PartialOrd,
Restrict a value to a certain interval. Read more
source§
impl PartialEq for SingleDiskFarmId
source§
fn eq(&self, other: &SingleDiskFarmId) -> bool
This method tests for self and other values to be equal, and is used
 by ==.
1.0.0 · source§
fn ne(&self, other: &Rhs) -> bool
This method tests for !=. The default implementation is almost always
-sufficient, and should not be overridden without very good reason.
source§
impl PartialOrd for SingleDiskFarmId
source§
fn partial_cmp(&self, other: &SingleDiskFarmId) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self and other) and is used by the <=
+sufficient, and should not be overridden without very good reason.
source§
impl PartialOrd for SingleDiskFarmId
source§
fn partial_cmp(&self, other: &SingleDiskFarmId) -> Option<Ordering>
This method returns an ordering between self and other values if one exists. Read more
1.0.0 · source§
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self and other) and is used by the < operator. Read more
1.0.0 · source§
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self and other) and is used by the <=
 operator. Read more
1.0.0 · source§
fn gt(&self, other: &Rhs) -> bool
This method tests greater than (for self and other) and is used by the > operator. Read more
1.0.0 · source§
fn ge(&self, other: &Rhs) -> bool
This method tests greater than or equal to (for self and other) and is used by the >=
-operator. Read more
source§
impl Serialize for SingleDiskFarmId
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 SingleDiskFarmId
source§
impl Eq for SingleDiskFarmId
source§
impl StructuralEq for SingleDiskFarmId
source§
impl StructuralPartialEq for SingleDiskFarmId
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
+operator. Read more
source§
impl Serialize for SingleDiskFarmId
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 SingleDiskFarmId
source§
impl Eq for SingleDiskFarmId
source§
impl StructuralEq for SingleDiskFarmId
source§
impl StructuralPartialEq for SingleDiskFarmId
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/enum.SingleDiskFarmInfo.html b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmInfo.html
index 0873966c74..92bda44a44 100644
--- a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmInfo.html
+++ b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmInfo.html
@@ -1,5 +1,5 @@
 SingleDiskFarmInfo in subspace_farmer::single_disk_farm - Rust

-    
Enum subspace_farmer::single_disk_farm::SingleDiskFarmInfo
source · 
pub enum SingleDiskFarmInfo {
+    
Enum subspace_farmer::single_disk_farm::SingleDiskFarmInfo
source · 
pub enum SingleDiskFarmInfo {
     V0 {
         id: SingleDiskFarmId,
         genesis_hash: [u8; 32],
@@ -14,21 +14,21 @@
 
§pieces_in_sector: u16
How many pieces does one sector contain.

 
§allocated_space: u64
How much space in bytes is allocated for this farm

 
V0 of the info

-
Implementations§
Implementations§
source§
impl SingleDiskFarmInfo
source
pub fn new(
     id: SingleDiskFarmId,
     genesis_hash: [u8; 32],
     public_key: PublicKey,
     pieces_in_sector: u16,
     allocated_space: u64
-) -> Self
source
pub fn load_from(directory: &Path) -> Result<Option<Self>>
Load SingleDiskFarm from path is supposed to be stored, None means no info file was
+) -> Self
source
pub fn load_from(directory: &Path) -> Result<Option<Self>>
Load SingleDiskFarm from path is supposed to be stored, None means no info file was
 found, happens during first start.

-
source
pub fn store_to(&self, directory: &Path) -> Result<()>
Store SingleDiskFarm info to path so it can be loaded again upon restart.

-
source
pub fn try_lock(directory: &Path) -> Result<SingleDiskFarmInfoLock>
Try to acquire exclusive lock on the single disk farm info file, ensuring no concurrent edits by cooperating
+
source
pub fn store_to(&self, directory: &Path) -> Result<()>
Store SingleDiskFarm info to path so it can be loaded again upon restart.

+
source
pub fn try_lock(directory: &Path) -> Result<SingleDiskFarmInfoLock>
Try to acquire exclusive lock on the single disk farm info file, ensuring no concurrent edits by cooperating
 processes is done

-
source
pub fn id(&self) -> &SingleDiskFarmId
source
pub fn genesis_hash(&self) -> &[u8; 32]
source
pub fn public_key(&self) -> &PublicKey
source
pub fn pieces_in_sector(&self) -> u16
How many pieces does one sector contain.

-
source
pub fn allocated_space(&self) -> u64
How much space in bytes is allocated for this farm

-
Trait Implementations§
source§
impl Clone for SingleDiskFarmInfo
source§
fn clone(&self) -> SingleDiskFarmInfo
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 SingleDiskFarmInfo
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl<'de> Deserialize<'de> for SingleDiskFarmInfo
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 SingleDiskFarmInfo
source§
fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>
where
+
source
pub fn id(&self) -> &SingleDiskFarmId
source
pub fn genesis_hash(&self) -> &[u8; 32]
source
pub fn public_key(&self) -> &PublicKey
source
pub fn pieces_in_sector(&self) -> u16
How many pieces does one sector contain.

+
source
pub fn allocated_space(&self) -> u64
How much space in bytes is allocated for this farm

+
Trait Implementations§
source§
impl Clone for SingleDiskFarmInfo
source§
fn clone(&self) -> SingleDiskFarmInfo
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 SingleDiskFarmInfo
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl<'de> Deserialize<'de> for SingleDiskFarmInfo
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 SingleDiskFarmInfo
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
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
diff --git a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmScrubError.html b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmScrubError.html
index 93aaf02068..930bf7be05 100644
--- a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmScrubError.html
+++ b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmScrubError.html
@@ -1,5 +1,5 @@
 SingleDiskFarmScrubError in subspace_farmer::single_disk_farm - Rust

-    
Enum subspace_farmer::single_disk_farm::SingleDiskFarmScrubError
source · 
pub enum SingleDiskFarmScrubError {
+    
Enum subspace_farmer::single_disk_farm::SingleDiskFarmScrubError
source · 
pub enum SingleDiskFarmScrubError {
 
Show 16 variants    LikelyAlreadyInUse(Error),
     FailedToDetermineFileSize {
         file: PathBuf,
@@ -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/enum.SingleDiskFarmSummary.html b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmSummary.html
index 7b5350a106..8cd83a0373 100644
--- a/subspace_farmer/single_disk_farm/enum.SingleDiskFarmSummary.html
+++ b/subspace_farmer/single_disk_farm/enum.SingleDiskFarmSummary.html
@@ -1,5 +1,5 @@
 SingleDiskFarmSummary in subspace_farmer::single_disk_farm - Rust

-    
Enum subspace_farmer::single_disk_farm::SingleDiskFarmSummary
source · 
pub enum SingleDiskFarmSummary {
+    
Enum subspace_farmer::single_disk_farm::SingleDiskFarmSummary
source · 
pub enum SingleDiskFarmSummary {
     Found {
         info: SingleDiskFarmInfo,
         directory: PathBuf,
@@ -20,7 +20,7 @@
 
§
Error
Fields
§directory: PathBuf
Path to directory where farm is stored.

 
§error: Error
Error itself

 
Failed to open farm

-
Trait Implementations§
source§
impl Debug for SingleDiskFarmSummary
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
+
Trait Implementations§
source§
impl Debug for SingleDiskFarmSummary
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
     T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
§
impl<'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 667b8b4b7b..8cf280db51 100644
--- a/subspace_farmer/single_disk_farm/farming/enum.FarmingError.html
+++ b/subspace_farmer/single_disk_farm/farming/enum.FarmingError.html
@@ -1,23 +1,35 @@
-FarmingError in subspace_farmer::single_disk_farm::farming - Rust

-    
Enum subspace_farmer::single_disk_farm::farming::FarmingError
source · 
pub enum FarmingError {
+FarmingError in subspace_farmer::single_disk_farm::farming - Rust

+    
Enum subspace_farmer::single_disk_farm::farming::FarmingError
source · 
pub enum FarmingError {
     FailedToSubscribeSlotInfo {
         error: Error,
     },
     FailedToGetFarmerInfo {
         error: Error,
     },
+    LowLevelAuditing(AuditingError),
     LowLevelProving(ProvingError),
     Io(Error),
     FailedToCreateThreadPool(ThreadPoolBuildError),
+    Decoded(DecodedFarmingError),
 }
Expand description
Errors that happen during farming

 
Variants§
§
FailedToSubscribeSlotInfo
Fields
§error: Error
Lower-level error

 
Failed to subscribe to slot info notifications

 
§
FailedToGetFarmerInfo
Fields
§error: Error
Lower-level error

 
Failed to retrieve farmer info

+
§
LowLevelAuditing(AuditingError)
Low-level auditing error

 
§
LowLevelProving(ProvingError)
Low-level proving error

 
§
Io(Error)
I/O error occurred

 
§
FailedToCreateThreadPool(ThreadPoolBuildError)
Failed to create thread pool

-
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 Display for FarmingError
source§
fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. 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<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
+
§
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>(
+    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
     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(
@@ -28,7 +40,14 @@
 ) -> TaggedParser<'a, Implicit, Self, E>
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
-    Self: Into<T>,
Converts self into T using Into<T>. Read more
§
impl<T> FmtForward for T
§
fn fmt_binary(self) -> FmtBinary<Self>
where
+    Self: Into<T>,
Converts self into T using Into<T>. Read more
§
impl<T> DecodeAll for T
where
+    T: Decode,
§
fn decode_all(input: &mut &[u8]) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
impl<T> DecodeLimit for T
where
+    T: Decode,
§
fn decode_all_with_depth_limit(
+    limit: u32,
+    input: &mut &[u8]
+) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>
where
+    I: Input,
Decode Self with the given maximum recursion depth and advance input by the number of
+bytes consumed. Read more
§
impl<T> FmtForward for T
§
fn fmt_binary(self) -> FmtBinary<Self>
where
     Self: Binary,
Causes self to use its Binary implementation when Debug-formatted.
§
fn fmt_display(self) -> FmtDisplay<Self>
where
     Self: Display,
Causes self to use its Display implementation when
 Debug-formatted.
§
fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where
@@ -43,14 +62,15 @@
 Debug-formatted.
§
fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where
     Self: UpperHex,
Causes self to use its UpperHex implementation when
 Debug-formatted.
§
fn fmt_list(self) -> FmtList<Self>
where
-    &'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

+    &'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

 
§
impl<T> Instrument for T
§
fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided [Span], returning an
 Instrumented wrapper. Read more
§
fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current Span, returning an
 Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
     U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

 
That is, this conversion is whatever the implementation of
 From<T> for U chooses to do.

-
§
impl<T> Pipe for T
where
+
§
impl<T> KeyedVec for T
where
+    T: Codec,
§
fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> ⓘ
Return an encoding of Self prepended by given slice.
§
impl<T> Pipe for T
where
     T: ?Sized,
§
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where
     Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
§
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where
     R: 'a,
Borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where
@@ -124,5 +144,12 @@
     V: MultiLane<T>,
§
fn vzip(self) -> V
§
impl<T> WithSubscriber for T
§
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
     S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
 [WithDispatch] wrapper. Read more
§
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber to this type, returning a
-[WithDispatch] wrapper. Read more
§
impl<T> JsonSchemaMaybe for T
§
impl<T> MaybeSend for T
where
-    T: Send,

\ No newline at end of file
+[WithDispatch] wrapper. Read more
§
impl<S> Codec for S
where
+    S: Decode + Encode,
§
impl<T> EncodeLike<&&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&mut T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Arc<T>> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Box<T>> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Rc<T>> for T
where
+    T: Encode,
§
impl<T> JsonSchemaMaybe for T
§
impl<T> MaybeSend for T
where
+    T: Send,

\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/farming/enum.FarmingNotification.html b/subspace_farmer/single_disk_farm/farming/enum.FarmingNotification.html
new file mode 100644
index 0000000000..efbb2a0764
--- /dev/null
+++ b/subspace_farmer/single_disk_farm/farming/enum.FarmingNotification.html
@@ -0,0 +1,147 @@
+FarmingNotification in subspace_farmer::single_disk_farm::farming - Rust

+    
Enum subspace_farmer::single_disk_farm::farming::FarmingNotification
source · 
pub enum FarmingNotification {
+    Auditing(AuditingDetails),
+    Proving(ProvingDetails),
+    NonFatalError(Arc<FarmingError>),
+}
Expand description
Various farming notifications

+
Variants§
§
Auditing(AuditingDetails)
Auditing

+
§
Proving(ProvingDetails)
Proving

+
§
NonFatalError(Arc<FarmingError>)
Non-fatal farming error

+
Trait Implementations§
source§
impl Clone for FarmingNotification
source§
fn clone(&self) -> FarmingNotification
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 FarmingNotification
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Decode for FarmingNotification
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 Encode for FarmingNotification
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
+    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 EncodeLike for FarmingNotification
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(
+    self,
+    class: Class,
+    constructed: bool,
+    tag: u32
+) -> TaggedParser<'a, Implicit, Self, E>
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
+    Self: Into<T>,
Converts self into T using Into<T>. Read more
§
impl<T> DecodeAll for T
where
+    T: Decode,
§
fn decode_all(input: &mut &[u8]) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
impl<T> DecodeLimit for T
where
+    T: Decode,
§
fn decode_all_with_depth_limit(
+    limit: u32,
+    input: &mut &[u8]
+) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>
where
+    I: Input,
Decode Self with the given maximum recursion depth and advance input by the number of
+bytes consumed. Read more
§
impl<T> FmtForward for T
§
fn fmt_binary(self) -> FmtBinary<Self>
where
+    Self: Binary,
Causes self to use its Binary implementation when Debug-formatted.
§
fn fmt_display(self) -> FmtDisplay<Self>
where
+    Self: Display,
Causes self to use its Display implementation when
+Debug-formatted.
§
fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where
+    Self: LowerExp,
Causes self to use its LowerExp implementation when
+Debug-formatted.
§
fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where
+    Self: LowerHex,
Causes self to use its LowerHex implementation when
+Debug-formatted.
§
fn fmt_octal(self) -> FmtOctal<Self>
where
+    Self: Octal,
Causes self to use its Octal implementation when Debug-formatted.
§
fn fmt_pointer(self) -> FmtPointer<Self>
where
+    Self: Pointer,
Causes self to use its Pointer implementation when
+Debug-formatted.
§
fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where
+    Self: UpperExp,
Causes self to use its UpperExp implementation when
+Debug-formatted.
§
fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where
+    Self: UpperHex,
Causes self to use its UpperHex implementation when
+Debug-formatted.
§
fn fmt_list(self) -> FmtList<Self>
where
+    &'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

+
§
impl<T> Instrument for T
§
fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided [Span], returning an
+Instrumented wrapper. Read more
§
fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current Span, returning an
+Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
+    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

+
That is, this conversion is whatever the implementation of
+From<T> for U chooses to do.

+
§
impl<T> KeyedVec for T
where
+    T: Codec,
§
fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> ⓘ
Return an encoding of Self prepended by given slice.
§
impl<T> Pipe for T
where
+    T: ?Sized,
§
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where
+    Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
§
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where
+    R: 'a,
Borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where
+    R: 'a,
Mutably borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where
+    Self: Borrow<B>,
+    B: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.borrow() into the pipe function. Read more
§
fn pipe_borrow_mut<'a, B, R>(
+    &'a mut self,
+    func: impl FnOnce(&'a mut B) -> R
+) -> R
where
+    Self: BorrowMut<B>,
+    B: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.borrow_mut() into the pipe
+function. Read more
§
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where
+    Self: AsRef<U>,
+    U: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.as_ref() into the pipe function.
§
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where
+    Self: AsMut<U>,
+    U: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.as_mut() into the pipe
+function.
§
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where
+    Self: Deref<Target = T>,
+    T: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.deref() into the pipe function.
§
fn pipe_deref_mut<'a, T, R>(
+    &'a mut self,
+    func: impl FnOnce(&'a mut T) -> R
+) -> R
where
+    Self: DerefMut<Target = T> + Deref,
+    T: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.deref_mut() into the pipe
+function.
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
§
type Output = T
Should always be Self
§
impl<T> SaturatedConversion for T
§
fn saturated_from<T>(t: T) -> Self
where
+    Self: UniqueSaturatedFrom<T>,
Convert from a value of T into an equivalent instance of Self. Read more
§
fn saturated_into<T>(self) -> T
where
+    Self: UniqueSaturatedInto<T>,
Consume self to return an equivalent value of T. Read more
§
impl<T> Tap for T
§
fn tap(self, func: impl FnOnce(&Self)) -> Self
Immutable access to a value. Read more
§
fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
Mutable access to a value. Read more
§
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where
+    Self: Borrow<B>,
+    B: ?Sized,
Immutable access to the Borrow<B> of a value. Read more
§
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where
+    Self: BorrowMut<B>,
+    B: ?Sized,
Mutable access to the BorrowMut<B> of a value. Read more
§
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where
+    Self: AsRef<R>,
+    R: ?Sized,
Immutable access to the AsRef<R> view of a value. Read more
§
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where
+    Self: AsMut<R>,
+    R: ?Sized,
Mutable access to the AsMut<R> view of a value. Read more
§
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where
+    Self: Deref<Target = T>,
+    T: ?Sized,
Immutable access to the Deref::Target of a value. Read more
§
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where
+    Self: DerefMut<Target = T> + Deref,
+    T: ?Sized,
Mutable access to the Deref::Target of a value. Read more
§
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls .tap() only in debug builds, and is erased in release builds.
§
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls .tap_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where
+    Self: Borrow<B>,
+    B: ?Sized,
Calls .tap_borrow() only in debug builds, and is erased in release
+builds.
§
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where
+    Self: BorrowMut<B>,
+    B: ?Sized,
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where
+    Self: AsRef<R>,
+    R: ?Sized,
Calls .tap_ref() only in debug builds, and is erased in release
+builds.
§
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where
+    Self: AsMut<R>,
+    R: ?Sized,
Calls .tap_ref_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where
+    Self: Deref<Target = T>,
+    T: ?Sized,
Calls .tap_deref() only in debug builds, and is erased in release
+builds.
§
fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where
+    Self: DerefMut<Target = T> + Deref,
+    T: ?Sized,
Calls .tap_deref_mut() only in debug builds, and is erased in release
+builds.
source§
impl<T> ToOwned for T
where
+    T: Clone,
§
type Owned = T
The resulting type after obtaining ownership.
source§
fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
source§
fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning. Read more
§
impl<T> TryConv for T
§
fn try_conv<T>(self) -> Result<T, Self::Error>
where
+    Self: TryInto<T>,
Attempts to convert self into T using TryInto<T>. Read more
source§
impl<T, U> TryFrom<U> for T
where
+    U: Into<T>,
§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
+    U: TryFrom<T>,
§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T, S> UniqueSaturatedInto<T> for S
where
+    T: Bounded,
+    S: TryInto<T>,
§
fn unique_saturated_into(self) -> T
Consume self to return an equivalent value of T.
§
impl<V, T> VZip<V> for T
where
+    V: MultiLane<T>,
§
fn vzip(self) -> V
§
impl<T> WithSubscriber for T
§
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
+    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more
§
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more
§
impl<S> Codec for S
where
+    S: Decode + Encode,
§
impl<T> EncodeLike<&&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&mut T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Arc<T>> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Box<T>> for T
where
+    T: Encode,
§
impl<'a, T> EncodeLike<Cow<'a, T>> for T
where
+    T: ToOwned + Encode,
§
impl<T> EncodeLike<Rc<T>> for T
where
+    T: Encode,
§
impl<S> FullCodec for S
where
+    S: Decode + FullEncode,
§
impl<S> FullEncode for S
where
+    S: Encode + EncodeLike,
§
impl<T> JsonSchemaMaybe for T
§
impl<T> MaybeSend for T
where
+    T: Send,

\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/farming/enum.ProvingResult.html b/subspace_farmer/single_disk_farm/farming/enum.ProvingResult.html
new file mode 100644
index 0000000000..1d44cd1fa5
--- /dev/null
+++ b/subspace_farmer/single_disk_farm/farming/enum.ProvingResult.html
@@ -0,0 +1,149 @@
+ProvingResult in subspace_farmer::single_disk_farm::farming - Rust

+    
Enum subspace_farmer::single_disk_farm::farming::ProvingResult
source · 
pub enum ProvingResult {
+    Success,
+    Timeout,
+    Rejected,
+}
Expand description
Result of the proving

+
Variants§
§
Success
Proved successfully and accepted by the node

+
§
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>(
+    __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>(
+    &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
+    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 Copy for ProvingResult
source§
impl EncodeLike for ProvingResult
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(
+    self,
+    class: Class,
+    constructed: bool,
+    tag: u32
+) -> TaggedParser<'a, Implicit, Self, E>
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
+    Self: Into<T>,
Converts self into T using Into<T>. Read more
§
impl<T> DecodeAll for T
where
+    T: Decode,
§
fn decode_all(input: &mut &[u8]) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
impl<T> DecodeLimit for T
where
+    T: Decode,
§
fn decode_all_with_depth_limit(
+    limit: u32,
+    input: &mut &[u8]
+) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>
where
+    I: Input,
Decode Self with the given maximum recursion depth and advance input by the number of
+bytes consumed. Read more
§
impl<T> FmtForward for T
§
fn fmt_binary(self) -> FmtBinary<Self>
where
+    Self: Binary,
Causes self to use its Binary implementation when Debug-formatted.
§
fn fmt_display(self) -> FmtDisplay<Self>
where
+    Self: Display,
Causes self to use its Display implementation when
+Debug-formatted.
§
fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where
+    Self: LowerExp,
Causes self to use its LowerExp implementation when
+Debug-formatted.
§
fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where
+    Self: LowerHex,
Causes self to use its LowerHex implementation when
+Debug-formatted.
§
fn fmt_octal(self) -> FmtOctal<Self>
where
+    Self: Octal,
Causes self to use its Octal implementation when Debug-formatted.
§
fn fmt_pointer(self) -> FmtPointer<Self>
where
+    Self: Pointer,
Causes self to use its Pointer implementation when
+Debug-formatted.
§
fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where
+    Self: UpperExp,
Causes self to use its UpperExp implementation when
+Debug-formatted.
§
fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where
+    Self: UpperHex,
Causes self to use its UpperHex implementation when
+Debug-formatted.
§
fn fmt_list(self) -> FmtList<Self>
where
+    &'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

+
§
impl<T> Instrument for T
§
fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided [Span], returning an
+Instrumented wrapper. Read more
§
fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current Span, returning an
+Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
+    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

+
That is, this conversion is whatever the implementation of
+From<T> for U chooses to do.

+
§
impl<T> KeyedVec for T
where
+    T: Codec,
§
fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> ⓘ
Return an encoding of Self prepended by given slice.
§
impl<T> Pipe for T
where
+    T: ?Sized,
§
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where
+    Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
§
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where
+    R: 'a,
Borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where
+    R: 'a,
Mutably borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where
+    Self: Borrow<B>,
+    B: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.borrow() into the pipe function. Read more
§
fn pipe_borrow_mut<'a, B, R>(
+    &'a mut self,
+    func: impl FnOnce(&'a mut B) -> R
+) -> R
where
+    Self: BorrowMut<B>,
+    B: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.borrow_mut() into the pipe
+function. Read more
§
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where
+    Self: AsRef<U>,
+    U: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.as_ref() into the pipe function.
§
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where
+    Self: AsMut<U>,
+    U: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.as_mut() into the pipe
+function.
§
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where
+    Self: Deref<Target = T>,
+    T: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.deref() into the pipe function.
§
fn pipe_deref_mut<'a, T, R>(
+    &'a mut self,
+    func: impl FnOnce(&'a mut T) -> R
+) -> R
where
+    Self: DerefMut<Target = T> + Deref,
+    T: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.deref_mut() into the pipe
+function.
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
§
type Output = T
Should always be Self
§
impl<T> SaturatedConversion for T
§
fn saturated_from<T>(t: T) -> Self
where
+    Self: UniqueSaturatedFrom<T>,
Convert from a value of T into an equivalent instance of Self. Read more
§
fn saturated_into<T>(self) -> T
where
+    Self: UniqueSaturatedInto<T>,
Consume self to return an equivalent value of T. Read more
§
impl<T> Tap for T
§
fn tap(self, func: impl FnOnce(&Self)) -> Self
Immutable access to a value. Read more
§
fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
Mutable access to a value. Read more
§
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where
+    Self: Borrow<B>,
+    B: ?Sized,
Immutable access to the Borrow<B> of a value. Read more
§
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where
+    Self: BorrowMut<B>,
+    B: ?Sized,
Mutable access to the BorrowMut<B> of a value. Read more
§
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where
+    Self: AsRef<R>,
+    R: ?Sized,
Immutable access to the AsRef<R> view of a value. Read more
§
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where
+    Self: AsMut<R>,
+    R: ?Sized,
Mutable access to the AsMut<R> view of a value. Read more
§
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where
+    Self: Deref<Target = T>,
+    T: ?Sized,
Immutable access to the Deref::Target of a value. Read more
§
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where
+    Self: DerefMut<Target = T> + Deref,
+    T: ?Sized,
Mutable access to the Deref::Target of a value. Read more
§
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls .tap() only in debug builds, and is erased in release builds.
§
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls .tap_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where
+    Self: Borrow<B>,
+    B: ?Sized,
Calls .tap_borrow() only in debug builds, and is erased in release
+builds.
§
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where
+    Self: BorrowMut<B>,
+    B: ?Sized,
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where
+    Self: AsRef<R>,
+    R: ?Sized,
Calls .tap_ref() only in debug builds, and is erased in release
+builds.
§
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where
+    Self: AsMut<R>,
+    R: ?Sized,
Calls .tap_ref_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where
+    Self: Deref<Target = T>,
+    T: ?Sized,
Calls .tap_deref() only in debug builds, and is erased in release
+builds.
§
fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where
+    Self: DerefMut<Target = T> + Deref,
+    T: ?Sized,
Calls .tap_deref_mut() only in debug builds, and is erased in release
+builds.
source§
impl<T> ToOwned for T
where
+    T: Clone,
§
type Owned = T
The resulting type after obtaining ownership.
source§
fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
source§
fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning. Read more
source§
impl<T> ToString for T
where
+    T: Display + ?Sized,
source§
default fn to_string(&self) -> String
Converts the given value to a String. Read more
§
impl<T> TryConv for T
§
fn try_conv<T>(self) -> Result<T, Self::Error>
where
+    Self: TryInto<T>,
Attempts to convert self into T using TryInto<T>. Read more
source§
impl<T, U> TryFrom<U> for T
where
+    U: Into<T>,
§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
+    U: TryFrom<T>,
§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T, S> UniqueSaturatedInto<T> for S
where
+    T: Bounded,
+    S: TryInto<T>,
§
fn unique_saturated_into(self) -> T
Consume self to return an equivalent value of T.
§
impl<V, T> VZip<V> for T
where
+    V: MultiLane<T>,
§
fn vzip(self) -> V
§
impl<T> WithSubscriber for T
§
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
+    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more
§
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more
§
impl<S> Codec for S
where
+    S: Decode + Encode,
§
impl<T> EncodeLike<&&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&mut T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Arc<T>> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Box<T>> for T
where
+    T: Encode,
§
impl<'a, T> EncodeLike<Cow<'a, T>> for T
where
+    T: ToOwned + Encode,
§
impl<T> EncodeLike<Rc<T>> for T
where
+    T: Encode,
§
impl<S> FullCodec for S
where
+    S: Decode + FullEncode,
§
impl<S> FullEncode for S
where
+    S: Encode + EncodeLike,
§
impl<T> JsonSchemaMaybe for T
§
impl<T> MaybeSend for T
where
+    T: Send,

\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/farming/index.html b/subspace_farmer/single_disk_farm/farming/index.html
index 31e8588165..8e2f8b2aad 100644
--- a/subspace_farmer/single_disk_farm/farming/index.html
+++ b/subspace_farmer/single_disk_farm/farming/index.html
@@ -1,2 +1,2 @@
 subspace_farmer::single_disk_farm::farming - Rust

-    
Module subspace_farmer::single_disk_farm::farming
source · 
Modules
Structs
Enums

\ No newline at end of file
+    
Module subspace_farmer::single_disk_farm::farming
source · 
Modules
Structs
Enums

\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/farming/sidebar-items.js b/subspace_farmer/single_disk_farm/farming/sidebar-items.js
index 82fa2809bc..8cadd0f860 100644
--- a/subspace_farmer/single_disk_farm/farming/sidebar-items.js
+++ b/subspace_farmer/single_disk_farm/farming/sidebar-items.js
@@ -1 +1 @@
-window.SIDEBAR_ITEMS = {"enum":["FarmingError"],"mod":["rayon_files"],"struct":["AuditEvent","PlotAudit","PlotAuditOptions"]};
\ No newline at end of file
+window.SIDEBAR_ITEMS = {"enum":["FarmingError","FarmingNotification","ProvingResult"],"mod":["rayon_files"],"struct":["AuditingDetails","DecodedFarmingError","PlotAudit","PlotAuditOptions","ProvingDetails"]};
\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/farming/struct.AuditingDetails.html b/subspace_farmer/single_disk_farm/farming/struct.AuditingDetails.html
new file mode 100644
index 0000000000..53dec8bdc8
--- /dev/null
+++ b/subspace_farmer/single_disk_farm/farming/struct.AuditingDetails.html
@@ -0,0 +1,145 @@
+AuditingDetails in subspace_farmer::single_disk_farm::farming - Rust

+    
Struct subspace_farmer::single_disk_farm::farming::AuditingDetails
source · 
pub struct AuditingDetails {
+    pub sectors_count: SectorIndex,
+    pub time: Duration,
+}
Expand description
Auditing details

+
Fields§
§sectors_count: SectorIndex
Number of sectors that were audited

+
§time: Duration
Audit duration

+
Trait Implementations§
source§
impl Clone for AuditingDetails
source§
fn clone(&self) -> AuditingDetails
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 AuditingDetails
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Decode for AuditingDetails
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 Encode for AuditingDetails
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
+    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 Copy for AuditingDetails
source§
impl EncodeLike for AuditingDetails
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(
+    self,
+    class: Class,
+    constructed: bool,
+    tag: u32
+) -> TaggedParser<'a, Implicit, Self, E>
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
+    Self: Into<T>,
Converts self into T using Into<T>. Read more
§
impl<T> DecodeAll for T
where
+    T: Decode,
§
fn decode_all(input: &mut &[u8]) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
impl<T> DecodeLimit for T
where
+    T: Decode,
§
fn decode_all_with_depth_limit(
+    limit: u32,
+    input: &mut &[u8]
+) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>
where
+    I: Input,
Decode Self with the given maximum recursion depth and advance input by the number of
+bytes consumed. Read more
§
impl<T> FmtForward for T
§
fn fmt_binary(self) -> FmtBinary<Self>
where
+    Self: Binary,
Causes self to use its Binary implementation when Debug-formatted.
§
fn fmt_display(self) -> FmtDisplay<Self>
where
+    Self: Display,
Causes self to use its Display implementation when
+Debug-formatted.
§
fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where
+    Self: LowerExp,
Causes self to use its LowerExp implementation when
+Debug-formatted.
§
fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where
+    Self: LowerHex,
Causes self to use its LowerHex implementation when
+Debug-formatted.
§
fn fmt_octal(self) -> FmtOctal<Self>
where
+    Self: Octal,
Causes self to use its Octal implementation when Debug-formatted.
§
fn fmt_pointer(self) -> FmtPointer<Self>
where
+    Self: Pointer,
Causes self to use its Pointer implementation when
+Debug-formatted.
§
fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where
+    Self: UpperExp,
Causes self to use its UpperExp implementation when
+Debug-formatted.
§
fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where
+    Self: UpperHex,
Causes self to use its UpperHex implementation when
+Debug-formatted.
§
fn fmt_list(self) -> FmtList<Self>
where
+    &'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

+
§
impl<T> Instrument for T
§
fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided [Span], returning an
+Instrumented wrapper. Read more
§
fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current Span, returning an
+Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
+    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

+
That is, this conversion is whatever the implementation of
+From<T> for U chooses to do.

+
§
impl<T> KeyedVec for T
where
+    T: Codec,
§
fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> ⓘ
Return an encoding of Self prepended by given slice.
§
impl<T> Pipe for T
where
+    T: ?Sized,
§
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where
+    Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
§
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where
+    R: 'a,
Borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where
+    R: 'a,
Mutably borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where
+    Self: Borrow<B>,
+    B: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.borrow() into the pipe function. Read more
§
fn pipe_borrow_mut<'a, B, R>(
+    &'a mut self,
+    func: impl FnOnce(&'a mut B) -> R
+) -> R
where
+    Self: BorrowMut<B>,
+    B: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.borrow_mut() into the pipe
+function. Read more
§
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where
+    Self: AsRef<U>,
+    U: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.as_ref() into the pipe function.
§
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where
+    Self: AsMut<U>,
+    U: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.as_mut() into the pipe
+function.
§
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where
+    Self: Deref<Target = T>,
+    T: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.deref() into the pipe function.
§
fn pipe_deref_mut<'a, T, R>(
+    &'a mut self,
+    func: impl FnOnce(&'a mut T) -> R
+) -> R
where
+    Self: DerefMut<Target = T> + Deref,
+    T: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.deref_mut() into the pipe
+function.
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
§
type Output = T
Should always be Self
§
impl<T> SaturatedConversion for T
§
fn saturated_from<T>(t: T) -> Self
where
+    Self: UniqueSaturatedFrom<T>,
Convert from a value of T into an equivalent instance of Self. Read more
§
fn saturated_into<T>(self) -> T
where
+    Self: UniqueSaturatedInto<T>,
Consume self to return an equivalent value of T. Read more
§
impl<T> Tap for T
§
fn tap(self, func: impl FnOnce(&Self)) -> Self
Immutable access to a value. Read more
§
fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
Mutable access to a value. Read more
§
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where
+    Self: Borrow<B>,
+    B: ?Sized,
Immutable access to the Borrow<B> of a value. Read more
§
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where
+    Self: BorrowMut<B>,
+    B: ?Sized,
Mutable access to the BorrowMut<B> of a value. Read more
§
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where
+    Self: AsRef<R>,
+    R: ?Sized,
Immutable access to the AsRef<R> view of a value. Read more
§
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where
+    Self: AsMut<R>,
+    R: ?Sized,
Mutable access to the AsMut<R> view of a value. Read more
§
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where
+    Self: Deref<Target = T>,
+    T: ?Sized,
Immutable access to the Deref::Target of a value. Read more
§
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where
+    Self: DerefMut<Target = T> + Deref,
+    T: ?Sized,
Mutable access to the Deref::Target of a value. Read more
§
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls .tap() only in debug builds, and is erased in release builds.
§
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls .tap_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where
+    Self: Borrow<B>,
+    B: ?Sized,
Calls .tap_borrow() only in debug builds, and is erased in release
+builds.
§
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where
+    Self: BorrowMut<B>,
+    B: ?Sized,
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where
+    Self: AsRef<R>,
+    R: ?Sized,
Calls .tap_ref() only in debug builds, and is erased in release
+builds.
§
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where
+    Self: AsMut<R>,
+    R: ?Sized,
Calls .tap_ref_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where
+    Self: Deref<Target = T>,
+    T: ?Sized,
Calls .tap_deref() only in debug builds, and is erased in release
+builds.
§
fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where
+    Self: DerefMut<Target = T> + Deref,
+    T: ?Sized,
Calls .tap_deref_mut() only in debug builds, and is erased in release
+builds.
source§
impl<T> ToOwned for T
where
+    T: Clone,
§
type Owned = T
The resulting type after obtaining ownership.
source§
fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
source§
fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning. Read more
§
impl<T> TryConv for T
§
fn try_conv<T>(self) -> Result<T, Self::Error>
where
+    Self: TryInto<T>,
Attempts to convert self into T using TryInto<T>. Read more
source§
impl<T, U> TryFrom<U> for T
where
+    U: Into<T>,
§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
+    U: TryFrom<T>,
§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T, S> UniqueSaturatedInto<T> for S
where
+    T: Bounded,
+    S: TryInto<T>,
§
fn unique_saturated_into(self) -> T
Consume self to return an equivalent value of T.
§
impl<V, T> VZip<V> for T
where
+    V: MultiLane<T>,
§
fn vzip(self) -> V
§
impl<T> WithSubscriber for T
§
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
+    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more
§
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more
§
impl<S> Codec for S
where
+    S: Decode + Encode,
§
impl<T> EncodeLike<&&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&mut T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Arc<T>> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Box<T>> for T
where
+    T: Encode,
§
impl<'a, T> EncodeLike<Cow<'a, T>> for T
where
+    T: ToOwned + Encode,
§
impl<T> EncodeLike<Rc<T>> for T
where
+    T: Encode,
§
impl<S> FullCodec for S
where
+    S: Decode + FullEncode,
§
impl<S> FullEncode for S
where
+    S: Encode + EncodeLike,
§
impl<T> JsonSchemaMaybe for T
§
impl<T> MaybeSend for T
where
+    T: Send,

\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/farming/struct.DecodedFarmingError.html b/subspace_farmer/single_disk_farm/farming/struct.DecodedFarmingError.html
new file mode 100644
index 0000000000..a6f30ccdb0
--- /dev/null
+++ b/subspace_farmer/single_disk_farm/farming/struct.DecodedFarmingError.html
@@ -0,0 +1,139 @@
+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>(
+    __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>(
+    &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
+    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 EncodeLike for DecodedFarmingError
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(
+    self,
+    class: Class,
+    constructed: bool,
+    tag: u32
+) -> TaggedParser<'a, Implicit, Self, E>
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
+    Self: Into<T>,
Converts self into T using Into<T>. Read more
§
impl<T> DecodeAll for T
where
+    T: Decode,
§
fn decode_all(input: &mut &[u8]) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
impl<T> DecodeLimit for T
where
+    T: Decode,
§
fn decode_all_with_depth_limit(
+    limit: u32,
+    input: &mut &[u8]
+) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>
where
+    I: Input,
Decode Self with the given maximum recursion depth and advance input by the number of
+bytes consumed. Read more
§
impl<T> FmtForward for T
§
fn fmt_binary(self) -> FmtBinary<Self>
where
+    Self: Binary,
Causes self to use its Binary implementation when Debug-formatted.
§
fn fmt_display(self) -> FmtDisplay<Self>
where
+    Self: Display,
Causes self to use its Display implementation when
+Debug-formatted.
§
fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where
+    Self: LowerExp,
Causes self to use its LowerExp implementation when
+Debug-formatted.
§
fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where
+    Self: LowerHex,
Causes self to use its LowerHex implementation when
+Debug-formatted.
§
fn fmt_octal(self) -> FmtOctal<Self>
where
+    Self: Octal,
Causes self to use its Octal implementation when Debug-formatted.
§
fn fmt_pointer(self) -> FmtPointer<Self>
where
+    Self: Pointer,
Causes self to use its Pointer implementation when
+Debug-formatted.
§
fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where
+    Self: UpperExp,
Causes self to use its UpperExp implementation when
+Debug-formatted.
§
fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where
+    Self: UpperHex,
Causes self to use its UpperHex implementation when
+Debug-formatted.
§
fn fmt_list(self) -> FmtList<Self>
where
+    &'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

+
§
impl<T> Instrument for T
§
fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided [Span], returning an
+Instrumented wrapper. Read more
§
fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current Span, returning an
+Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
+    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

+
That is, this conversion is whatever the implementation of
+From<T> for U chooses to do.

+
§
impl<T> KeyedVec for T
where
+    T: Codec,
§
fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> ⓘ
Return an encoding of Self prepended by given slice.
§
impl<T> Pipe for T
where
+    T: ?Sized,
§
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where
+    Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
§
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where
+    R: 'a,
Borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where
+    R: 'a,
Mutably borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where
+    Self: Borrow<B>,
+    B: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.borrow() into the pipe function. Read more
§
fn pipe_borrow_mut<'a, B, R>(
+    &'a mut self,
+    func: impl FnOnce(&'a mut B) -> R
+) -> R
where
+    Self: BorrowMut<B>,
+    B: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.borrow_mut() into the pipe
+function. Read more
§
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where
+    Self: AsRef<U>,
+    U: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.as_ref() into the pipe function.
§
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where
+    Self: AsMut<U>,
+    U: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.as_mut() into the pipe
+function.
§
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where
+    Self: Deref<Target = T>,
+    T: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.deref() into the pipe function.
§
fn pipe_deref_mut<'a, T, R>(
+    &'a mut self,
+    func: impl FnOnce(&'a mut T) -> R
+) -> R
where
+    Self: DerefMut<Target = T> + Deref,
+    T: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.deref_mut() into the pipe
+function.
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
§
type Output = T
Should always be Self
§
impl<T> SaturatedConversion for T
§
fn saturated_from<T>(t: T) -> Self
where
+    Self: UniqueSaturatedFrom<T>,
Convert from a value of T into an equivalent instance of Self. Read more
§
fn saturated_into<T>(self) -> T
where
+    Self: UniqueSaturatedInto<T>,
Consume self to return an equivalent value of T. Read more
§
impl<T> Tap for T
§
fn tap(self, func: impl FnOnce(&Self)) -> Self
Immutable access to a value. Read more
§
fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
Mutable access to a value. Read more
§
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where
+    Self: Borrow<B>,
+    B: ?Sized,
Immutable access to the Borrow<B> of a value. Read more
§
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where
+    Self: BorrowMut<B>,
+    B: ?Sized,
Mutable access to the BorrowMut<B> of a value. Read more
§
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where
+    Self: AsRef<R>,
+    R: ?Sized,
Immutable access to the AsRef<R> view of a value. Read more
§
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where
+    Self: AsMut<R>,
+    R: ?Sized,
Mutable access to the AsMut<R> view of a value. Read more
§
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where
+    Self: Deref<Target = T>,
+    T: ?Sized,
Immutable access to the Deref::Target of a value. Read more
§
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where
+    Self: DerefMut<Target = T> + Deref,
+    T: ?Sized,
Mutable access to the Deref::Target of a value. Read more
§
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls .tap() only in debug builds, and is erased in release builds.
§
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls .tap_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where
+    Self: Borrow<B>,
+    B: ?Sized,
Calls .tap_borrow() only in debug builds, and is erased in release
+builds.
§
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where
+    Self: BorrowMut<B>,
+    B: ?Sized,
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where
+    Self: AsRef<R>,
+    R: ?Sized,
Calls .tap_ref() only in debug builds, and is erased in release
+builds.
§
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where
+    Self: AsMut<R>,
+    R: ?Sized,
Calls .tap_ref_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where
+    Self: Deref<Target = T>,
+    T: ?Sized,
Calls .tap_deref() only in debug builds, and is erased in release
+builds.
§
fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where
+    Self: DerefMut<Target = T> + Deref,
+    T: ?Sized,
Calls .tap_deref_mut() only in debug builds, and is erased in release
+builds.
source§
impl<T> ToString for T
where
+    T: Display + ?Sized,
source§
default fn to_string(&self) -> String
Converts the given value to a String. Read more
§
impl<T> TryConv for T
§
fn try_conv<T>(self) -> Result<T, Self::Error>
where
+    Self: TryInto<T>,
Attempts to convert self into T using TryInto<T>. Read more
source§
impl<T, U> TryFrom<U> for T
where
+    U: Into<T>,
§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
+    U: TryFrom<T>,
§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T, S> UniqueSaturatedInto<T> for S
where
+    T: Bounded,
+    S: TryInto<T>,
§
fn unique_saturated_into(self) -> T
Consume self to return an equivalent value of T.
§
impl<V, T> VZip<V> for T
where
+    V: MultiLane<T>,
§
fn vzip(self) -> V
§
impl<T> WithSubscriber for T
§
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
+    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more
§
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more
§
impl<S> Codec for S
where
+    S: Decode + Encode,
§
impl<T> EncodeLike<&&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&mut T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Arc<T>> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Box<T>> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Rc<T>> for T
where
+    T: Encode,
§
impl<S> FullCodec for S
where
+    S: Decode + FullEncode,
§
impl<S> FullEncode for S
where
+    S: Encode + EncodeLike,
§
impl<T> JsonSchemaMaybe for T
§
impl<T> MaybeSend for T
where
+    T: Send,

\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/farming/struct.PlotAudit.html b/subspace_farmer/single_disk_farm/farming/struct.PlotAudit.html
index 6004db8347..db8aab8791 100644
--- a/subspace_farmer/single_disk_farm/farming/struct.PlotAudit.html
+++ b/subspace_farmer/single_disk_farm/farming/struct.PlotAudit.html
@@ -1,13 +1,13 @@
 PlotAudit in subspace_farmer::single_disk_farm::farming - Rust

-    
Struct subspace_farmer::single_disk_farm::farming::PlotAudit
source · 
pub struct PlotAudit<Plot>(/* private fields */)
+    
Struct subspace_farmer::single_disk_farm::farming::PlotAudit
source · 
pub struct PlotAudit<Plot>(/* private fields */)
 where
     Plot: ReadAtSync;
Expand description
Plot auditing implementation

-
Implementations§
source§
impl<'a, Plot> PlotAudit<Plot>
where
-    Plot: ReadAtSync + 'a,
source
pub fn new(plot: Plot) -> Self
Create new instance

-
source
pub fn audit<PosTable>(
+
Implementations§
source§
impl<'a, Plot> PlotAudit<Plot>
where
+    Plot: ReadAtSync + 'a,
source
pub fn new(plot: Plot) -> Self
Create new instance

+
source
pub fn audit<PosTable>(
     &'a self,
     options: PlotAuditOptions<'a, PosTable>
-) -> Vec<(SectorIndex, impl ProvableSolutions<Item = Result<Solution<PublicKey, PublicKey>, ProvingError>> + 'a)>
where
+) -> Result<Vec<(SectorIndex, impl ProvableSolutions<Item = Result<Solution<PublicKey, PublicKey>, ProvingError>> + 'a)>, AuditingError>
where
     PosTable: Table,
Auto Trait Implementations§
§
impl<Plot> RefUnwindSafe for PlotAudit<Plot>
where
     Plot: RefUnwindSafe,
§
impl<Plot> Send for PlotAudit<Plot>
§
impl<Plot> Sync for PlotAudit<Plot>
§
impl<Plot> Unpin for PlotAudit<Plot>
where
     Plot: Unpin,
§
impl<Plot> UnwindSafe for PlotAudit<Plot>
where
diff --git a/subspace_farmer/single_disk_farm/farming/struct.PlotAuditOptions.html b/subspace_farmer/single_disk_farm/farming/struct.PlotAuditOptions.html
index 1b97ec0217..0f5c47445e 100644
--- a/subspace_farmer/single_disk_farm/farming/struct.PlotAuditOptions.html
+++ b/subspace_farmer/single_disk_farm/farming/struct.PlotAuditOptions.html
@@ -1,5 +1,5 @@
 PlotAuditOptions in subspace_farmer::single_disk_farm::farming - Rust

-    
Struct subspace_farmer::single_disk_farm::farming::PlotAuditOptions
source · 
pub struct PlotAuditOptions<'a, PosTable>
where
+    
Struct subspace_farmer::single_disk_farm::farming::PlotAuditOptions
source · 
pub struct PlotAuditOptions<'a, PosTable>
where
     PosTable: Table,
{
     pub public_key: &'a PublicKey,
     pub reward_address: &'a PublicKey,
@@ -19,10 +19,10 @@
 
§maybe_sector_being_modified: Option<SectorIndex>
Optional sector that is currently being modified (for example replotted) and should not be
 audited

 
§table_generator: &'a Mutex<PosTable::Generator>
Proof of space table generator

-
Trait Implementations§
source§
impl<'a, PosTable> Clone for PlotAuditOptions<'a, PosTable>
where
-    PosTable: Table,
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, PosTable> Debug for PlotAuditOptions<'a, PosTable>
where
+
Trait Implementations§
source§
impl<'a, PosTable> Clone for PlotAuditOptions<'a, PosTable>
where
+    PosTable: Table,
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, PosTable> Debug for PlotAuditOptions<'a, PosTable>
where
     PosTable: Table + Debug,
-    PosTable::Generator: Debug,
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl<'a, PosTable> Copy for PlotAuditOptions<'a, PosTable>
where
+    PosTable::Generator: Debug,
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl<'a, PosTable> Copy for PlotAuditOptions<'a, PosTable>
where
     PosTable: Table,
Auto Trait Implementations§
§
impl<'a, PosTable> !RefUnwindSafe for PlotAuditOptions<'a, PosTable>
§
impl<'a, PosTable> Send for PlotAuditOptions<'a, PosTable>
§
impl<'a, PosTable> Sync for PlotAuditOptions<'a, PosTable>
§
impl<'a, PosTable> Unpin for PlotAuditOptions<'a, PosTable>
§
impl<'a, PosTable> !UnwindSafe for PlotAuditOptions<'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
§
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
diff --git a/subspace_farmer/single_disk_farm/farming/struct.ProvingDetails.html b/subspace_farmer/single_disk_farm/farming/struct.ProvingDetails.html
new file mode 100644
index 0000000000..9fcff55b5a
--- /dev/null
+++ b/subspace_farmer/single_disk_farm/farming/struct.ProvingDetails.html
@@ -0,0 +1,145 @@
+ProvingDetails in subspace_farmer::single_disk_farm::farming - Rust

+    
Struct subspace_farmer::single_disk_farm::farming::ProvingDetails
source · 
pub struct ProvingDetails {
+    pub result: ProvingResult,
+    pub time: Duration,
+}
Expand description
Proving details

+
Fields§
§result: ProvingResult
Whether proving ended up being successful

+
§time: Duration
Audit duration

+
Trait Implementations§
source§
impl Clone for ProvingDetails
source§
fn clone(&self) -> ProvingDetails
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 ProvingDetails
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Decode for ProvingDetails
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 Encode for ProvingDetails
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
+    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 Copy for ProvingDetails
source§
impl EncodeLike for ProvingDetails
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(
+    self,
+    class: Class,
+    constructed: bool,
+    tag: u32
+) -> TaggedParser<'a, Implicit, Self, E>
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
+    Self: Into<T>,
Converts self into T using Into<T>. Read more
§
impl<T> DecodeAll for T
where
+    T: Decode,
§
fn decode_all(input: &mut &[u8]) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
impl<T> DecodeLimit for T
where
+    T: Decode,
§
fn decode_all_with_depth_limit(
+    limit: u32,
+    input: &mut &[u8]
+) -> Result<T, Error>
Decode Self and consume all of the given input data. Read more
§
fn decode_with_depth_limit<I>(limit: u32, input: &mut I) -> Result<T, Error>
where
+    I: Input,
Decode Self with the given maximum recursion depth and advance input by the number of
+bytes consumed. Read more
§
impl<T> FmtForward for T
§
fn fmt_binary(self) -> FmtBinary<Self>
where
+    Self: Binary,
Causes self to use its Binary implementation when Debug-formatted.
§
fn fmt_display(self) -> FmtDisplay<Self>
where
+    Self: Display,
Causes self to use its Display implementation when
+Debug-formatted.
§
fn fmt_lower_exp(self) -> FmtLowerExp<Self>
where
+    Self: LowerExp,
Causes self to use its LowerExp implementation when
+Debug-formatted.
§
fn fmt_lower_hex(self) -> FmtLowerHex<Self>
where
+    Self: LowerHex,
Causes self to use its LowerHex implementation when
+Debug-formatted.
§
fn fmt_octal(self) -> FmtOctal<Self>
where
+    Self: Octal,
Causes self to use its Octal implementation when Debug-formatted.
§
fn fmt_pointer(self) -> FmtPointer<Self>
where
+    Self: Pointer,
Causes self to use its Pointer implementation when
+Debug-formatted.
§
fn fmt_upper_exp(self) -> FmtUpperExp<Self>
where
+    Self: UpperExp,
Causes self to use its UpperExp implementation when
+Debug-formatted.
§
fn fmt_upper_hex(self) -> FmtUpperHex<Self>
where
+    Self: UpperHex,
Causes self to use its UpperHex implementation when
+Debug-formatted.
§
fn fmt_list(self) -> FmtList<Self>
where
+    &'a Self: for<'a> IntoIterator,
Formats each item in a sequence. Read more
source§
impl<T> From<T> for T
source§
fn from(t: T) -> T
Returns the argument unchanged.

+
§
impl<T> Instrument for T
§
fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided [Span], returning an
+Instrumented wrapper. Read more
§
fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current Span, returning an
+Instrumented wrapper. Read more
source§
impl<T, U> Into<U> for T
where
+    U: From<T>,
source§
fn into(self) -> U
Calls U::from(self).

+
That is, this conversion is whatever the implementation of
+From<T> for U chooses to do.

+
§
impl<T> KeyedVec for T
where
+    T: Codec,
§
fn to_keyed_vec(&self, prepend_key: &[u8]) -> Vec<u8> ⓘ
Return an encoding of Self prepended by given slice.
§
impl<T> Pipe for T
where
+    T: ?Sized,
§
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> R
where
+    Self: Sized,
Pipes by value. This is generally the method you want to use. Read more
§
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> R
where
+    R: 'a,
Borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> R
where
+    R: 'a,
Mutably borrows self and passes that borrow into the pipe function. Read more
§
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
where
+    Self: Borrow<B>,
+    B: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.borrow() into the pipe function. Read more
§
fn pipe_borrow_mut<'a, B, R>(
+    &'a mut self,
+    func: impl FnOnce(&'a mut B) -> R
+) -> R
where
+    Self: BorrowMut<B>,
+    B: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.borrow_mut() into the pipe
+function. Read more
§
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
where
+    Self: AsRef<U>,
+    U: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.as_ref() into the pipe function.
§
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
where
+    Self: AsMut<U>,
+    U: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.as_mut() into the pipe
+function.
§
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
where
+    Self: Deref<Target = T>,
+    T: 'a + ?Sized,
+    R: 'a,
Borrows self, then passes self.deref() into the pipe function.
§
fn pipe_deref_mut<'a, T, R>(
+    &'a mut self,
+    func: impl FnOnce(&'a mut T) -> R
+) -> R
where
+    Self: DerefMut<Target = T> + Deref,
+    T: 'a + ?Sized,
+    R: 'a,
Mutably borrows self, then passes self.deref_mut() into the pipe
+function.
§
impl<T> Pointable for T
§
const ALIGN: usize = _
The alignment of pointer.
§
type Init = T
The type for initializers.
§
unsafe fn init(init: <T as Pointable>::Init) -> usize
Initializes a with the given initializer. Read more
§
unsafe fn deref<'a>(ptr: usize) -> &'a T
Dereferences the given pointer. Read more
§
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T
Mutably dereferences the given pointer. Read more
§
unsafe fn drop(ptr: usize)
Drops the object pointed to by the given pointer. Read more
source§
impl<T> Same for T
§
type Output = T
Should always be Self
§
impl<T> SaturatedConversion for T
§
fn saturated_from<T>(t: T) -> Self
where
+    Self: UniqueSaturatedFrom<T>,
Convert from a value of T into an equivalent instance of Self. Read more
§
fn saturated_into<T>(self) -> T
where
+    Self: UniqueSaturatedInto<T>,
Consume self to return an equivalent value of T. Read more
§
impl<T> Tap for T
§
fn tap(self, func: impl FnOnce(&Self)) -> Self
Immutable access to a value. Read more
§
fn tap_mut(self, func: impl FnOnce(&mut Self)) -> Self
Mutable access to a value. Read more
§
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
where
+    Self: Borrow<B>,
+    B: ?Sized,
Immutable access to the Borrow<B> of a value. Read more
§
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
where
+    Self: BorrowMut<B>,
+    B: ?Sized,
Mutable access to the BorrowMut<B> of a value. Read more
§
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
where
+    Self: AsRef<R>,
+    R: ?Sized,
Immutable access to the AsRef<R> view of a value. Read more
§
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
where
+    Self: AsMut<R>,
+    R: ?Sized,
Mutable access to the AsMut<R> view of a value. Read more
§
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
where
+    Self: Deref<Target = T>,
+    T: ?Sized,
Immutable access to the Deref::Target of a value. Read more
§
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
where
+    Self: DerefMut<Target = T> + Deref,
+    T: ?Sized,
Mutable access to the Deref::Target of a value. Read more
§
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
Calls .tap() only in debug builds, and is erased in release builds.
§
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
Calls .tap_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
where
+    Self: Borrow<B>,
+    B: ?Sized,
Calls .tap_borrow() only in debug builds, and is erased in release
+builds.
§
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
where
+    Self: BorrowMut<B>,
+    B: ?Sized,
Calls .tap_borrow_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
where
+    Self: AsRef<R>,
+    R: ?Sized,
Calls .tap_ref() only in debug builds, and is erased in release
+builds.
§
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
where
+    Self: AsMut<R>,
+    R: ?Sized,
Calls .tap_ref_mut() only in debug builds, and is erased in release
+builds.
§
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
where
+    Self: Deref<Target = T>,
+    T: ?Sized,
Calls .tap_deref() only in debug builds, and is erased in release
+builds.
§
fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where
+    Self: DerefMut<Target = T> + Deref,
+    T: ?Sized,
Calls .tap_deref_mut() only in debug builds, and is erased in release
+builds.
source§
impl<T> ToOwned for T
where
+    T: Clone,
§
type Owned = T
The resulting type after obtaining ownership.
source§
fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
source§
fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning. Read more
§
impl<T> TryConv for T
§
fn try_conv<T>(self) -> Result<T, Self::Error>
where
+    Self: TryInto<T>,
Attempts to convert self into T using TryInto<T>. Read more
source§
impl<T, U> TryFrom<U> for T
where
+    U: Into<T>,
§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
+    U: TryFrom<T>,
§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T, S> UniqueSaturatedInto<T> for S
where
+    T: Bounded,
+    S: TryInto<T>,
§
fn unique_saturated_into(self) -> T
Consume self to return an equivalent value of T.
§
impl<V, T> VZip<V> for T
where
+    V: MultiLane<T>,
§
fn vzip(self) -> V
§
impl<T> WithSubscriber for T
§
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
+    S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more
§
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber to this type, returning a
+[WithDispatch] wrapper. Read more
§
impl<S> Codec for S
where
+    S: Decode + Encode,
§
impl<T> EncodeLike<&&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<&mut T> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Arc<T>> for T
where
+    T: Encode,
§
impl<T> EncodeLike<Box<T>> for T
where
+    T: Encode,
§
impl<'a, T> EncodeLike<Cow<'a, T>> for T
where
+    T: ToOwned + Encode,
§
impl<T> EncodeLike<Rc<T>> for T
where
+    T: Encode,
§
impl<S> FullCodec for S
where
+    S: Decode + FullEncode,
§
impl<S> FullEncode for S
where
+    S: Encode + EncodeLike,
§
impl<T> JsonSchemaMaybe for T
§
impl<T> MaybeSend for T
where
+    T: Send,

\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/index.html b/subspace_farmer/single_disk_farm/index.html
index 146c4a212f..7d3f94e8a2 100644
--- a/subspace_farmer/single_disk_farm/index.html
+++ b/subspace_farmer/single_disk_farm/index.html
@@ -1,3 +1,3 @@
 subspace_farmer::single_disk_farm - Rust

-    
Module subspace_farmer::single_disk_farm
source · 
Re-exports
Modules
Structs
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§
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§
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/plotting/enum.SectorExpirationDetails.html b/subspace_farmer/single_disk_farm/plotting/enum.SectorExpirationDetails.html
new file mode 100644
index 0000000000..808e7b87b2
--- /dev/null
+++ b/subspace_farmer/single_disk_farm/plotting/enum.SectorExpirationDetails.html
@@ -0,0 +1,11 @@
+
+
+
+    
+    Redirection
+
+
+    
Redirecting to ../../../subspace_farmer/single_disk_farm/enum.SectorExpirationDetails.html...

+    
+
+
\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/plotting/enum.SectorPlottingDetails.html b/subspace_farmer/single_disk_farm/plotting/enum.SectorPlottingDetails.html
new file mode 100644
index 0000000000..42ff5fa411
--- /dev/null
+++ b/subspace_farmer/single_disk_farm/plotting/enum.SectorPlottingDetails.html
@@ -0,0 +1,11 @@
+
+
+
+    
+    Redirection
+
+
+    
Redirecting to ../../../subspace_farmer/single_disk_farm/enum.SectorPlottingDetails.html...

+    
+
+
\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/struct.SingleDiskFarm.html b/subspace_farmer/single_disk_farm/struct.SingleDiskFarm.html
index c8c46803e8..a131ed840b 100644
--- a/subspace_farmer/single_disk_farm/struct.SingleDiskFarm.html
+++ b/subspace_farmer/single_disk_farm/struct.SingleDiskFarm.html
@@ -1,8 +1,8 @@
-SingleDiskFarm in subspace_farmer::single_disk_farm - Rust

-    
Struct subspace_farmer::single_disk_farm::SingleDiskFarm
source · 
pub struct SingleDiskFarm { /* private fields */ }
Expand description
Single disk farm abstraction is a container for everything necessary to plot/farm with a single
+SingleDiskFarm in subspace_farmer::single_disk_farm - Rust

+    
Struct subspace_farmer::single_disk_farm::SingleDiskFarm
source · 
pub struct SingleDiskFarm { /* private fields */ }
Expand description
Single disk farm abstraction is a container for everything necessary to plot/farm with a single
 disk.

 
Farm starts operating during creation and doesn’t stop until dropped (or error happens).

-
Implementations§
source§
impl SingleDiskFarm
source
pub const PLOT_FILE: &'static str = "plot.bin"
source
pub const METADATA_FILE: &'static str = "metadata.bin"
source
pub async fn new<NC, PG, PosTable>(
+
Implementations§
source§
impl SingleDiskFarm
source
pub const PLOT_FILE: &'static str = "plot.bin"
source
pub const METADATA_FILE: &'static str = "metadata.bin"
source
pub async fn new<NC, PG, PosTable>(
     options: SingleDiskFarmOptions<NC, PG>,
     disk_farm_index: usize
 ) -> Result<Self, SingleDiskFarmError>
where
@@ -10,36 +10,36 @@
     PG: PieceGetter + Clone + Send + Sync + 'static,
     PosTable: Table,
Create new single disk farm instance

 
NOTE: Though this function is async, it will do some blocking I/O.

-
source
pub fn collect_summary(directory: PathBuf) -> SingleDiskFarmSummary
Collect summary of single disk farm for presentational purposes

-
source
pub fn read_all_sectors_metadata(
+
source
pub fn collect_summary(directory: PathBuf) -> SingleDiskFarmSummary
Collect summary of single disk farm for presentational purposes

+
source
pub fn read_all_sectors_metadata(
     directory: &Path
 ) -> Result<Vec<SectorMetadataChecksummed>>
Read all sectors metadata

-
source
pub fn id(&self) -> &SingleDiskFarmId
ID of this farm

-
source
pub fn info(&self) -> &SingleDiskFarmInfo
Info of this farm

-
source
pub fn total_sectors_count(&self) -> SectorIndex
Number of sectors in this farm

-
source
pub async fn plotted_sectors_count(&self) -> usize
Number of sectors successfully plotted so far

-
source
pub async fn plotted_sectors(
+
source
pub fn id(&self) -> &SingleDiskFarmId
ID of this farm

+
source
pub fn info(&self) -> &SingleDiskFarmInfo
Info of this farm

+
source
pub fn total_sectors_count(&self) -> SectorIndex
Number of sectors in this farm

+
source
pub async fn plotted_sectors_count(&self) -> usize
Number of sectors successfully plotted so far

+
source
pub async fn plotted_sectors(
     &self
 ) -> impl Iterator<Item = Result<PlottedSector, Error>> + '_
Read information about sectors plotted so far

-
source
pub fn piece_cache(&self) -> DiskPieceCache
Get piece cache instance

-
source
pub fn piece_reader(&self) -> PieceReader
Get piece reader to read plotted pieces later

-
source
pub fn on_sector_update(
+
source
pub fn piece_cache(&self) -> DiskPieceCache
Get piece cache instance

+
source
pub fn piece_reader(&self) -> PieceReader
Get piece reader to read plotted pieces later

+
source
pub fn on_sector_update(
     &self,
     callback: Arc<dyn Fn(&(SectorIndex, SectorUpdate)) + Send + Sync + 'static>
 ) -> HandlerId
Subscribe to sector updates

-
source
pub fn on_plot_audited(
+
source
pub fn on_farming_notification(
     &self,
-    callback: Arc<dyn Fn(&AuditEvent) + Send + Sync + 'static>
-) -> HandlerId
Subscribe to notification about audited plots

-
source
pub fn on_solution(
+    callback: Arc<dyn Fn(&FarmingNotification) + Send + Sync + 'static>
+) -> HandlerId
Subscribe to farming notifications

+
source
pub fn on_solution(
     &self,
     callback: Arc<dyn Fn(&SolutionResponse) + Send + Sync + 'static>
 ) -> HandlerId
Subscribe to new solution notification

-
source
pub async fn run(self) -> Result<SingleDiskFarmId>
Run and wait for background threads to exit or return an error

-
source
pub fn wipe(directory: &Path) -> Result<()>
Wipe everything that belongs to this single disk farm

-
source
pub fn scrub(directory: &Path) -> Result<(), SingleDiskFarmScrubError>
Check the farm for corruption and repair errors (caused by disk errors or something else),
+
source
pub async fn run(self) -> Result<SingleDiskFarmId>
Run and wait for background threads to exit or return an error

+
source
pub fn wipe(directory: &Path) -> Result<()>
Wipe everything that belongs to this single disk farm

+
source
pub fn scrub(directory: &Path) -> Result<(), SingleDiskFarmScrubError>
Check the farm for corruption and repair errors (caused by disk errors or something else),
 returns an error when irrecoverable errors occur.

-
Trait Implementations§
source§
impl Drop for SingleDiskFarm
source§
fn drop(&mut self)
Executes the destructor for this type. Read more
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
+
Trait Implementations§
source§
impl Drop for SingleDiskFarm
source§
fn drop(&mut self)
Executes the destructor for this type. 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/struct.SingleDiskFarmInfoLock.html b/subspace_farmer/single_disk_farm/struct.SingleDiskFarmInfoLock.html
index d0e7429d20..627839d703 100644
--- a/subspace_farmer/single_disk_farm/struct.SingleDiskFarmInfoLock.html
+++ b/subspace_farmer/single_disk_farm/struct.SingleDiskFarmInfoLock.html
@@ -1,5 +1,5 @@
 SingleDiskFarmInfoLock in subspace_farmer::single_disk_farm - Rust

-    
Struct subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock
source · 
pub struct SingleDiskFarmInfoLock { /* private fields */ }
Expand description
Exclusive lock for single disk farm info file, ensuring no concurrent edits by cooperating processes is done

+    
Struct subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock
source · 
pub struct SingleDiskFarmInfoLock { /* private fields */ }
Expand description
Exclusive lock for single disk farm info file, ensuring no concurrent edits by cooperating processes is done

 
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
diff --git a/subspace_farmer/single_disk_farm/struct.SingleDiskFarmOptions.html b/subspace_farmer/single_disk_farm/struct.SingleDiskFarmOptions.html
index 91f18008d3..95c652b4c5 100644
--- a/subspace_farmer/single_disk_farm/struct.SingleDiskFarmOptions.html
+++ b/subspace_farmer/single_disk_farm/struct.SingleDiskFarmOptions.html
@@ -1,5 +1,5 @@
 SingleDiskFarmOptions in subspace_farmer::single_disk_farm - Rust

-    
Struct subspace_farmer::single_disk_farm::SingleDiskFarmOptions
source · 
pub struct SingleDiskFarmOptions<NC, PG> {
Show 15 fields
+    
Struct subspace_farmer::single_disk_farm::SingleDiskFarmOptions
source · 
pub struct SingleDiskFarmOptions<NC, PG> {
Show 15 fields
     pub directory: PathBuf,
     pub farmer_app_info: FarmerAppInfo,
     pub allocated_space: u64,
diff --git a/subspace_farmer_components/all.html b/subspace_farmer_components/all.html
index 41c1b24872..ba65a9016e 100644
--- a/subspace_farmer_components/all.html
+++ b/subspace_farmer_components/all.html
@@ -1,2 +1,2 @@
 List of all items in this crate

-    
List of all items
Structs
Enums
Traits
Functions

\ No newline at end of file
+    
List of all items
Structs
Enums
Traits
Functions

\ No newline at end of file
diff --git a/subspace_farmer/single_disk_farm/farming/struct.AuditEvent.html b/subspace_farmer_components/auditing/enum.AuditingError.html
similarity index 71%
rename from subspace_farmer/single_disk_farm/farming/struct.AuditEvent.html
rename to subspace_farmer_components/auditing/enum.AuditingError.html
index 5b7d6a4c28..2e25464145 100644
--- a/subspace_farmer/single_disk_farm/farming/struct.AuditEvent.html
+++ b/subspace_farmer_components/auditing/enum.AuditingError.html
@@ -1,20 +1,17 @@
-AuditEvent in subspace_farmer::single_disk_farm::farming - Rust

-    
Struct subspace_farmer::single_disk_farm::farming::AuditEvent
source · 
pub struct AuditEvent {
-    pub duration: f64,
-    pub farm_id: SingleDiskFarmId,
-    pub sectors_number: usize,
-}
Fields§
§duration: f64
Defines how much time took the audit in secs

-
§farm_id: SingleDiskFarmId
ID of the farm

-
§sectors_number: usize
Number of sectors for this audit

-
Trait Implementations§
source§
impl Clone for AuditEvent
source§
fn clone(&self) -> AuditEvent
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 AuditEvent
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
-    T: 'static + ?Sized,
source§
fn type_id(&self) -> TypeId
Gets the TypeId of self. Read more
§
impl<'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(
-    self,
-    class: Class,
-    constructed: bool,
-    tag: u32
-) -> TaggedParser<'a, Implicit, Self, E>
source§
impl<T> Borrow<T> for T
where
+AuditingError in subspace_farmer_components::auditing - Rust

+    
Enum subspace_farmer_components::auditing::AuditingError
source · 
pub enum AuditingError {
+    SBucketReading {
+        sector_index: SectorIndex,
+        s_bucket_audit_index: SBucket,
+        error: Error,
+    },
+}
Expand description
Errors that happen during proving

+
Variants§
§
SBucketReading
Fields
§sector_index: SectorIndex
Sector index

+
§s_bucket_audit_index: SBucket
S-bucket audit index

+
§error: Error
Low-level error

+
Failed read s-bucket

+
Trait Implementations§
source§
impl Debug for AuditingError
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Display for AuditingError
source§
fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Error for AuditingError
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
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
     Self: Into<T>,
Converts self into T using Into<T>. Read more
§
impl<T> FmtForward for T
§
fn fmt_binary(self) -> FmtBinary<Self>
where
@@ -103,8 +100,8 @@
 builds.
§
fn tap_deref_mut_dbg<T>(self, func: impl FnOnce(&mut T)) -> Self
where
     Self: DerefMut<Target = T> + Deref,
     T: ?Sized,
Calls .tap_deref_mut() only in debug builds, and is erased in release
-builds.
source§
impl<T> ToOwned for T
where
-    T: Clone,
§
type Owned = T
The resulting type after obtaining ownership.
source§
fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning. Read more
source§
fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning. Read more
§
impl<T> TryConv for T
§
fn try_conv<T>(self) -> Result<T, Self::Error>
where
+builds.
source§
impl<T> ToString for T
where
+    T: Display + ?Sized,
source§
default fn to_string(&self) -> String
Converts the given value to a String. Read more
§
impl<T> TryConv for T
§
fn try_conv<T>(self) -> Result<T, Self::Error>
where
     Self: TryInto<T>,
Attempts to convert self into T using TryInto<T>. Read more
source§
impl<T, U> TryFrom<U> for T
where
     U: Into<T>,
§
type Error = Infallible
The type returned in the event of a conversion error.
source§
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.
source§
impl<T, U> TryInto<U> for T
where
     U: TryFrom<T>,
§
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
source§
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
§
impl<T, S> UniqueSaturatedInto<T> for S
where
@@ -113,5 +110,4 @@
     V: MultiLane<T>,
§
fn vzip(self) -> V
§
impl<T> WithSubscriber for T
§
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where
     S: Into<Dispatch>,
Attaches the provided Subscriber to this type, returning a
 [WithDispatch] wrapper. Read more
§
fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default Subscriber to this type, returning a
-[WithDispatch] wrapper. Read more
§
impl<T> JsonSchemaMaybe for T
§
impl<T> MaybeSend for T
where
-    T: Send,

\ No newline at end of file
+[WithDispatch] wrapper. Read more
§
impl<T> JsonSchemaMaybe for T

\ No newline at end of file
diff --git a/subspace_farmer_components/auditing/fn.audit_plot_sync.html b/subspace_farmer_components/auditing/fn.audit_plot_sync.html
index 195f9b8ea0..9e168ec229 100644
--- a/subspace_farmer_components/auditing/fn.audit_plot_sync.html
+++ b/subspace_farmer_components/auditing/fn.audit_plot_sync.html
@@ -1,11 +1,11 @@
 audit_plot_sync in subspace_farmer_components::auditing - Rust

-    
Function subspace_farmer_components::auditing::audit_plot_sync
source · 
pub fn audit_plot_sync<'a, Plot>(
+    
Function subspace_farmer_components::auditing::audit_plot_sync
source · 
pub fn audit_plot_sync<'a, Plot>(
     public_key: &'a PublicKey,
     global_challenge: &Blake3Hash,
     solution_range: SolutionRange,
     plot: &'a Plot,
     sectors_metadata: &'a [SectorMetadataChecksummed],
     maybe_sector_being_modified: Option<SectorIndex>
-) -> Vec<AuditResult<'a, ReadAtOffset<'a, Plot>>>
where
+) -> Result<Vec<AuditResult<'a, ReadAtOffset<'a, Plot>>>, AuditingError>
where
     Plot: ReadAtSync + 'a,
Expand description
Audit the whole plot and generate streams of solutions

 

\ No newline at end of file
diff --git a/subspace_farmer_components/auditing/fn.audit_sector_sync.html b/subspace_farmer_components/auditing/fn.audit_sector_sync.html
index f9a441a5b1..ab349c16a9 100644
--- a/subspace_farmer_components/auditing/fn.audit_sector_sync.html
+++ b/subspace_farmer_components/auditing/fn.audit_sector_sync.html
@@ -1,11 +1,11 @@
 audit_sector_sync in subspace_farmer_components::auditing - Rust

-    
Function subspace_farmer_components::auditing::audit_sector_sync
source · 
pub fn audit_sector_sync<'a, Sector>(
+    
Function subspace_farmer_components::auditing::audit_sector_sync
source · 
pub fn audit_sector_sync<'a, Sector>(
     public_key: &'a PublicKey,
     global_challenge: &Blake3Hash,
     solution_range: SolutionRange,
     sector: Sector,
     sector_metadata: &'a SectorMetadataChecksummed
-) -> Option<AuditResult<'a, Sector>>
where
+) -> Result<Option<AuditResult<'a, Sector>>, AuditingError>
where
     Sector: ReadAtSync + 'a,
Expand description
Audit a single sector and generate a stream of solutions.

 
This is primarily helpful in test environment, prefer audit_plot_sync for auditing real plots.

 

\ No newline at end of file
diff --git a/subspace_farmer_components/auditing/index.html b/subspace_farmer_components/auditing/index.html
index a749b771f2..6e70381b50 100644
--- a/subspace_farmer_components/auditing/index.html
+++ b/subspace_farmer_components/auditing/index.html
@@ -1,2 +1,2 @@
-subspace_farmer_components::auditing - Rust

-    
Module subspace_farmer_components::auditing
source · 
Structs
Functions

\ No newline at end of file
+subspace_farmer_components::auditing - Rust

+    
Module subspace_farmer_components::auditing
source · 
Structs
Enums
Functions

\ No newline at end of file
diff --git a/subspace_farmer_components/auditing/sidebar-items.js b/subspace_farmer_components/auditing/sidebar-items.js
index c00fca2444..ed19f3f803 100644
--- a/subspace_farmer_components/auditing/sidebar-items.js
+++ b/subspace_farmer_components/auditing/sidebar-items.js
@@ -1 +1 @@
-window.SIDEBAR_ITEMS = {"fn":["audit_plot_sync","audit_sector_sync"],"struct":["AuditResult"]};
\ No newline at end of file
+window.SIDEBAR_ITEMS = {"enum":["AuditingError"],"fn":["audit_plot_sync","audit_sector_sync"],"struct":["AuditResult"]};
\ No newline at end of file
diff --git a/subspace_farmer_components/auditing/struct.AuditResult.html b/subspace_farmer_components/auditing/struct.AuditResult.html
index 751d7fdd91..426a82ccbd 100644
--- a/subspace_farmer_components/auditing/struct.AuditResult.html
+++ b/subspace_farmer_components/auditing/struct.AuditResult.html
@@ -1,5 +1,5 @@
 AuditResult in subspace_farmer_components::auditing - Rust

-    
Struct subspace_farmer_components::auditing::AuditResult
source · 
pub struct AuditResult<'a, Sector>
where
+    
Struct subspace_farmer_components::auditing::AuditResult
source · 
pub struct AuditResult<'a, Sector>
where
     Sector: 'a,
{
     pub sector_index: SectorIndex,
     pub solution_candidates: SolutionCandidates<'a, Sector>,
@@ -8,9 +8,9 @@
 
Fields§
§sector_index: SectorIndex
Sector index

 
§solution_candidates: SolutionCandidates<'a, Sector>
Solution candidates

 
§best_solution_distance: SolutionRange
Best solution distance found

-
Trait Implementations§
source§
impl<'a, Sector> Clone for AuditResult<'a, Sector>
where
-    Sector: 'a + Clone,
source§
fn clone(&self) -> AuditResult<'a, Sector>
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 AuditResult<'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 AuditResult<'a, Sector>
where
+
Trait Implementations§
source§
impl<'a, Sector> Clone for AuditResult<'a, Sector>
where
+    Sector: 'a + Clone,
source§
fn clone(&self) -> AuditResult<'a, Sector>
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 AuditResult<'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 AuditResult<'a, Sector>
where
     Sector: RefUnwindSafe,
§
impl<'a, Sector> Send for AuditResult<'a, Sector>
where
     Sector: Send,
§
impl<'a, Sector> Sync for AuditResult<'a, Sector>
where
     Sector: Sync,
§
impl<'a, Sector> Unpin for AuditResult<'a, Sector>
where
diff --git a/subspace_farmer_components/proving/enum.ProvingError.html b/subspace_farmer_components/proving/enum.ProvingError.html
index 3aecb7aeb8..7b2fda912b 100644
--- a/subspace_farmer_components/proving/enum.ProvingError.html
+++ b/subspace_farmer_components/proving/enum.ProvingError.html
@@ -1,4 +1,4 @@
-ProvingError in subspace_farmer_components::proving - Rust

+ProvingError in subspace_farmer_components::proving - Rust

     
Enum subspace_farmer_components::proving::ProvingError
source · 
pub enum ProvingError {
     InvalidErasureCodingInstance,
     FailedToCreatePolynomialForRecord {
@@ -25,7 +25,8 @@
 
§
FailedToDecodeSectorContentsMap(SectorContentsMapFromBytesError)
Failed to decode sector contents map

 
§
Io(Error)
I/O error occurred

 
§
RecordReadingError(ReadingError)
Record reading error

-
Trait Implementations§
source§
impl Debug for ProvingError
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Display for ProvingError
source§
fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Error for ProvingError
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 ProvingError
source§
fn from(source: Error) -> Self
Converts to this type from the input type.
source§
impl From<ReadingError> for ProvingError
source§
fn from(source: ReadingError) -> Self
Converts to this type from the input type.
source§
impl From<SectorContentsMapFromBytesError> for ProvingError
source§
fn from(source: SectorContentsMapFromBytesError) -> Self
Converts to this type from the input type.
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
+
Implementations§
source§
impl ProvingError
source
pub fn is_fatal(&self) -> bool
Whether this error is fatal and makes farm unusable

+
Trait Implementations§
source§
impl Debug for ProvingError
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Display for ProvingError
source§
fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Error for ProvingError
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 ProvingError
source§
fn from(source: Error) -> Self
Converts to this type from the input type.
source§
impl From<ReadingError> for ProvingError
source§
fn from(source: ReadingError) -> Self
Converts to this type from the input type.
source§
impl From<SectorContentsMapFromBytesError> for ProvingError
source§
fn from(source: SectorContentsMapFromBytesError) -> Self
Converts to this type from the input type.
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
§
impl<T> Conv for T
§
fn conv<T>(self) -> T
where
diff --git a/subspace_farmer_components/proving/index.html b/subspace_farmer_components/proving/index.html
index 36b627c13d..9759f4d136 100644
--- a/subspace_farmer_components/proving/index.html
+++ b/subspace_farmer_components/proving/index.html
@@ -1,2 +1,2 @@
 subspace_farmer_components::proving - Rust

-    
Module subspace_farmer_components::proving
source · 
Structs
Enums
Traits

\ No newline at end of file
+    
Module subspace_farmer_components::proving
source · 
Structs
Enums
Traits

\ No newline at end of file
diff --git a/subspace_farmer_components/proving/struct.SolutionCandidates.html b/subspace_farmer_components/proving/struct.SolutionCandidates.html
index efdbec1b55..ee4453f209 100644
--- a/subspace_farmer_components/proving/struct.SolutionCandidates.html
+++ b/subspace_farmer_components/proving/struct.SolutionCandidates.html
@@ -1,10 +1,10 @@
 SolutionCandidates in subspace_farmer_components::proving - Rust

-    
Struct subspace_farmer_components::proving::SolutionCandidates
source · 
pub struct SolutionCandidates<'a, Sector>
where
+    
Struct subspace_farmer_components::proving::SolutionCandidates
source · 
pub struct SolutionCandidates<'a, Sector>
where
     Sector: 'a,
{ /* private fields */ }
Expand description
Container for solution candidates.

-
Implementations§
source§
impl<'a, Sector> SolutionCandidates<'a, Sector>
where
-    Sector: ReadAtSync + 'a,
source
pub fn len(&self) -> usize
Total number of candidates

-
source
pub fn is_empty(&self) -> bool
Returns true if no candidates inside

-
source
pub fn into_solutions<RewardAddress, PosTable, TableGenerator>(
+
Implementations§
source§
impl<'a, Sector> SolutionCandidates<'a, Sector>
where
+    Sector: ReadAtSync + 'a,
source
pub fn len(&self) -> usize
Total number of candidates

+
source
pub fn is_empty(&self) -> bool
Returns true if no candidates inside

+
source
pub fn into_solutions<RewardAddress, PosTable, TableGenerator>(
     self,
     reward_address: &'a RewardAddress,
     kzg: &'a Kzg,
@@ -14,9 +14,9 @@
     RewardAddress: Copy,
     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
+
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
     Sector: RefUnwindSafe,
§
impl<'a, Sector> Send for SolutionCandidates<'a, Sector>
where
     Sector: Send,
§
impl<'a, Sector> Sync for SolutionCandidates<'a, Sector>
where
     Sector: Sync,
§
impl<'a, Sector> Unpin for SolutionCandidates<'a, Sector>
where
diff --git a/subspace_farmer_components/reading/enum.ReadingError.html b/subspace_farmer_components/reading/enum.ReadingError.html
index 72f4cd637d..c7fbe78ed7 100644
--- a/subspace_farmer_components/reading/enum.ReadingError.html
+++ b/subspace_farmer_components/reading/enum.ReadingError.html
@@ -1,4 +1,4 @@
-ReadingError in subspace_farmer_components::reading - Rust

+ReadingError in subspace_farmer_components::reading - Rust

     
Enum subspace_farmer_components::reading::ReadingError
source · 
pub enum ReadingError {
     FailedToReadChunk {
         chunk_location: usize,
@@ -41,7 +41,8 @@
 
§
FailedToDecodeSectorContentsMap(SectorContentsMapFromBytesError)
Failed to decode sector contents map

 
§
Io(Error)
I/O error occurred

 
§
ChecksumMismatch
Checksum mismatch

-
Trait Implementations§
source§
impl Debug for ReadingError
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Display for ReadingError
source§
fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Error for ReadingError
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 ReadingError
source§
fn from(source: Error) -> Self
Converts to this type from the input type.
source§
impl From<ReadingError> for ProvingError
source§
fn from(source: ReadingError) -> Self
Converts to this type from the input type.
source§
impl From<SectorContentsMapFromBytesError> for ReadingError
source§
fn from(source: SectorContentsMapFromBytesError) -> Self
Converts to this type from the input type.
Auto Trait Implementations§
Blanket Implementations§
source§
impl<T> Any for T
where
+
Implementations§
source§
impl ReadingError
source
pub fn is_fatal(&self) -> bool
Whether this error is fatal and renders farm unusable

+
Trait Implementations§
source§
impl Debug for ReadingError
source§
fn fmt(&self, f: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Display for ReadingError
source§
fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result
Formats the value using the given formatter. Read more
source§
impl Error for ReadingError
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 ReadingError
source§
fn from(source: Error) -> Self
Converts to this type from the input type.
source§
impl From<ReadingError> for ProvingError
source§
fn from(source: ReadingError) -> Self
Converts to this type from the input type.
source§
impl From<SectorContentsMapFromBytesError> for ReadingError
source§
fn from(source: SectorContentsMapFromBytesError) -> Self
Converts to this type from the input type.
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
§
impl<T> Conv for T
§
fn conv<T>(self) -> T
where
diff --git a/subspace_farmer_components/reading/fn.read_piece.html b/subspace_farmer_components/reading/fn.read_piece.html
index e99a0358ff..caa6025e6e 100644
--- a/subspace_farmer_components/reading/fn.read_piece.html
+++ b/subspace_farmer_components/reading/fn.read_piece.html
@@ -1,5 +1,5 @@
 read_piece in subspace_farmer_components::reading - Rust

-    
Function subspace_farmer_components::reading::read_piece
source · 
pub async fn read_piece<PosTable, S, A>(
+    
Function subspace_farmer_components::reading::read_piece
source · 
pub async fn read_piece<PosTable, S, A>(
     piece_offset: PieceOffset,
     sector_id: &SectorId,
     sector_metadata: &SectorMetadataChecksummed,
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 7fcf185d0c..95f12a3edc 100644
--- a/subspace_farmer_components/reading/fn.read_sector_record_chunks.html
+++ b/subspace_farmer_components/reading/fn.read_sector_record_chunks.html
@@ -1,5 +1,5 @@
 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>(
+    
Function subspace_farmer_components::reading::read_sector_record_chunks
source · 
pub async fn read_sector_record_chunks<PosTable, S, A>(
     piece_offset: PieceOffset,
     pieces_in_sector: u16,
     s_bucket_offsets: &[u32; 65536],
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 3c760f1407..d629f7a85c 100644
--- a/subspace_farmer_components/reading/fn.recover_extended_record_chunks.html
+++ b/subspace_farmer_components/reading/fn.recover_extended_record_chunks.html
@@ -1,5 +1,5 @@
 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(
+    
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,
     erasure_coding: &ErasureCoding
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 8cc63b0367..7c1e4afd37 100644
--- a/subspace_farmer_components/reading/fn.recover_source_record_chunks.html
+++ b/subspace_farmer_components/reading/fn.recover_source_record_chunks.html
@@ -1,5 +1,5 @@
 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(
+    
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,
     erasure_coding: &ErasureCoding
diff --git a/subspace_farmer_components/reading/index.html b/subspace_farmer_components/reading/index.html
index d288c6a8a6..c3e55231b8 100644
--- a/subspace_farmer_components/reading/index.html
+++ b/subspace_farmer_components/reading/index.html
@@ -1,2 +1,2 @@
 subspace_farmer_components::reading - Rust

-    
Module subspace_farmer_components::reading
source · 
Structs
Enums
Functions

\ No newline at end of file
+    
Module subspace_farmer_components::reading
source · 
Structs
Enums
Functions

\ 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 dde62bb5c0..3247fc7559 100644
--- a/subspace_farmer_components/reading/struct.PlotRecord.html
+++ b/subspace_farmer_components/reading/struct.PlotRecord.html
@@ -1,5 +1,5 @@
 PlotRecord in subspace_farmer_components::reading - Rust

-    
Struct subspace_farmer_components::reading::PlotRecord
source · 
pub struct PlotRecord {
+    
Struct subspace_farmer_components::reading::PlotRecord
source · 
pub struct PlotRecord {
     pub scalars: Box<[Scalar; 32768]>,
     pub commitment: RecordCommitment,
     pub witness: RecordWitness,
@@ -7,7 +7,7 @@
 
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
+
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
     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_service/fn.new_full.html b/subspace_service/fn.new_full.html
index 641f5c1b80..24214cb53d 100644
--- a/subspace_service/fn.new_full.html
+++ b/subspace_service/fn.new_full.html
@@ -7,5 +7,5 @@
 ) -> Result<NewFull<FullClient<RuntimeApi>>, Error>
where
     PosTable: Table,
     RuntimeApi: ConstructRuntimeApi<Block, FullClient<RuntimeApi>> + Send + Sync + 'static,
-    RuntimeApi::RuntimeApi: ApiExt<Block> + Metadata<Block> + AccountNonceApi<Block, AccountId, Nonce> + BlockBuilder<Block> + OffchainWorkerApi<Block> + SessionKeys<Block> + TaggedTransactionQueue<Block> + TransactionPaymentApi<Block, Balance> + SubspaceApi<Block, FarmerPublicKey> + DomainsApi<Block, Header> + FraudProofApi<Block, Header> + ObjectsApi<Block> + MmrApi<Block, Hash, BlockNumber>,
Expand description
Builds a new service for a full client.

+    RuntimeApi::RuntimeApi: ApiExt<Block> + Metadata<Block> + AccountNonceApi<Block, AccountId, Nonce> + BlockBuilder<Block> + OffchainWorkerApi<Block> + SessionKeys<Block> + TaggedTransactionQueue<Block> + TransactionPaymentApi<Block, Balance> + SubspaceApi<Block, FarmerPublicKey> + DomainsApi<Block, Header> + FraudProofApi<Block, Header> + ObjectsApi<Block> + MmrApi<Block, Hash, BlockNumber>,
Expand description

Builds a new service for a full client.

\ No newline at end of file diff --git a/subspace_service/fn.new_partial.html b/subspace_service/fn.new_partial.html index a668ff9ab8..93ce61030c 100644 --- a/subspace_service/fn.new_partial.html +++ b/subspace_service/fn.new_partial.html @@ -5,5 +5,5 @@ ) -> Result<PartialComponents<FullClient<RuntimeApi>, FullBackend, FullSelectChain, DefaultImportQueue<Block>, FullPool<FullClient<RuntimeApi>, Block, Header>, OtherPartialComponents<RuntimeApi>>, Error>
where PosTable: Table, RuntimeApi: ConstructRuntimeApi<Block, FullClient<RuntimeApi>> + Send + Sync + 'static, - RuntimeApi::RuntimeApi: ApiExt<Block> + Metadata<Block> + BlockBuilder<Block> + OffchainWorkerApi<Block> + SessionKeys<Block> + TaggedTransactionQueue<Block> + SubspaceApi<Block, FarmerPublicKey> + DomainsApi<Block, Header> + FraudProofApi<Block, Header> + BundleProducerElectionApi<Block, Balance> + ObjectsApi<Block>,
Expand description

Creates PartialComponents for Subspace client.

+ RuntimeApi::RuntimeApi: ApiExt<Block> + Metadata<Block> + BlockBuilder<Block> + OffchainWorkerApi<Block> + SessionKeys<Block> + TaggedTransactionQueue<Block> + SubspaceApi<Block, FarmerPublicKey> + DomainsApi<Block, Header> + FraudProofApi<Block, Header> + BundleProducerElectionApi<Block, Balance> + ObjectsApi<Block>,
Expand description

Creates PartialComponents for Subspace client.

\ No newline at end of file diff --git a/subspace_service/struct.NewFull.html b/subspace_service/struct.NewFull.html index d1ee90794e..6562af8080 100644 --- a/subspace_service/struct.NewFull.html +++ b/subspace_service/struct.NewFull.html @@ -1,7 +1,7 @@ NewFull in subspace_service - Rust

Struct subspace_service::NewFull

source · 
pub struct NewFull<Client>
where
     Client: ProvideRuntimeApi<Block> + AuxStore + BlockBackend<Block> + BlockIdTo<Block> + HeaderBackend<Block> + HeaderMetadata<Block, Error = Error> + 'static,
-    Client::Api: TaggedTransactionQueue<Block> + DomainsApi<Block, Header> + FraudProofApi<Block, Header> + SubspaceApi<Block, FarmerPublicKey>,
{
Show 14 fields
+    Client::Api: TaggedTransactionQueue<Block> + DomainsApi<Block, Header> + FraudProofApi<Block, Header> + SubspaceApi<Block, FarmerPublicKey>,
{
Show 14 fields pub task_manager: TaskManager, pub client: Arc<Client>, pub select_chain: FullSelectChain, diff --git a/subspace_service/transaction_pool/fn.new_full.html b/subspace_service/transaction_pool/fn.new_full.html index 9579ac4db6..c2512ea461 100644 --- a/subspace_service/transaction_pool/fn.new_full.html +++ b/subspace_service/transaction_pool/fn.new_full.html @@ -11,4 +11,4 @@ <<<Block as BlockT>::Header as HeaderT>::Number as TryInto<u32>>::Error: Debug, Client: ProvideRuntimeApi<Block> + AuxStore + BlockBackend<Block> + HeaderBackend<Block> + HeaderMetadata<Block, Error = Error> + ExecutorProvider<Block> + UsageProvider<Block> + BlockIdTo<Block> + Send + Sync + 'static, DomainHeader: HeaderT, - Client::Api: TaggedTransactionQueue<Block> + SubspaceApi<Block, FarmerPublicKey> + FraudProofApi<Block, DomainHeader> + DomainsApi<Block, DomainHeader>,
\ No newline at end of file + Client::Api: TaggedTransactionQueue<Block> + SubspaceApi<Block, FarmerPublicKey> + FraudProofApi<Block, DomainHeader> + DomainsApi<Block, DomainHeader>, \ No newline at end of file diff --git a/subspace_service/transaction_pool/struct.BasicPoolWrapper.html b/subspace_service/transaction_pool/struct.BasicPoolWrapper.html index 53254995d9..3fcbc7fff1 100644 --- a/subspace_service/transaction_pool/struct.BasicPoolWrapper.html +++ b/subspace_service/transaction_pool/struct.BasicPoolWrapper.html @@ -9,7 +9,7 @@ <<<Block as BlockT>::Header as HeaderT>::Number as TryInto<u32>>::Error: Debug, DomainHeader: HeaderT, Client: ProvideRuntimeApi<Block> + AuxStore + BlockBackend<Block> + BlockIdTo<Block> + HeaderBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync + 'static, - Client::Api: TaggedTransactionQueue<Block> + SubspaceApi<Block, FarmerPublicKey> + FraudProofApi<Block, DomainHeader> + DomainsApi<Block, DomainHeader>,
§

type Block = Block

Block type.
§

type Hash = <<FullChainApiWrapper<Client, Block, DomainHeader> as ChainApi>::Block as Block>::Hash

Transaction hash type.
§

type Error = <FullChainApiWrapper<Client, Block, DomainHeader> as ChainApi>::Error

Error type.
source§

fn submit_local( + Client::Api: TaggedTransactionQueue<Block> + SubspaceApi<Block, FarmerPublicKey> + FraudProofApi<Block, DomainHeader> + DomainsApi<Block, DomainHeader>,

§

type Block = Block

Block type.
§

type Hash = <<FullChainApiWrapper<Client, Block, DomainHeader> as ChainApi>::Block as Block>::Hash

Transaction hash type.
§

type Error = <FullChainApiWrapper<Client, Block, DomainHeader> as ChainApi>::Error

Error type.
source§

fn submit_local( &self, at: Block::Hash, xt: LocalTransactionFor<Self> diff --git a/subspace_service/type.HostFunctions.html b/subspace_service/type.HostFunctions.html index bdb493880f..008ea36de3 100644 --- a/subspace_service/type.HostFunctions.html +++ b/subspace_service/type.HostFunctions.html @@ -1,3 +1,3 @@ HostFunctions in subspace_service - Rust
-

Type Alias subspace_service::HostFunctions

source · 
pub type HostFunctions = (SubstrateHostFunctions, HostFunctions, HostFunctions, HostFunctions);
Expand description

Host functions required for Subspace

+

Type Alias subspace_service::HostFunctions

source · 
pub type HostFunctions = (SubstrateHostFunctions, HostFunctions, HostFunctions, HostFunctions);
Expand description

Host functions required for Subspace

\ 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/index.html b/subspace_test_client/index.html index f74c8dd7e9..58bb0f4b8a 100644 --- a/subspace_test_client/index.html +++ b/subspace_test_client/index.html @@ -1,4 +1,4 @@ subspace_test_client - Rust
-

Crate subspace_test_client

source ·
Expand description

Subspace test client only.

+

Crate subspace_test_client

source ·
Expand description

Subspace test client only.

Modules

Functions

Type Aliases

  • Backend
    The backend type being used by the test service.
  • Client
    The client type being used by the test service.
\ 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/trait.impl/core/clone/trait.Clone.js b/trait.impl/core/clone/trait.Clone.js index e3620ed838..ab0c93f8bb 100644 --- a/trait.impl/core/clone/trait.Clone.js +++ b/trait.impl/core/clone/trait.Clone.js @@ -34,8 +34,8 @@ "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 SingleDiskFarmInfo"],["impl Clone for SectorUpdate"],["impl Clone for DiskPieceCache"],["impl Clone for Offset"],["impl<'a, PosTable> Clone for PlotAuditOptions<'a, PosTable>
where\n PosTable: Table,
"],["impl Clone for NodeRpcClient"],["impl Clone for SingleDiskFarmId"],["impl Clone for Identity"],["impl Clone for SectorPlottingDetails"],["impl Clone for AuditEvent"],["impl Clone for PieceReader"],["impl Clone for PieceCache"],["impl<NC: Clone> Clone for SegmentCommitmentPieceValidator<NC>"],["impl Clone for SectorExpirationDetails"],["impl Clone for CpuCoreSet"],["impl Clone for PlottingThreadPoolManager"]], -"subspace_farmer_components":[["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 Clone for SectorMetadataChecksummed"],["impl Clone for SectorContentsMap"],["impl Clone for SectorContentsMapFromBytesError"],["impl<'a, Sector> Clone for AuditResult<'a, Sector>
where\n Sector: 'a + Clone,
"],["impl Clone for PlotRecord"],["impl<'a, Sector> Clone for SolutionCandidates<'a, Sector>
where\n Sector: Clone + 'a,
"],["impl Clone for PlottedSector"],["impl Clone for SectorContentsMapIterationError"],["impl Clone for SectorContentsMapEncodeIntoError"],["impl Clone for SectorMetadata"],["impl<'a, T: Clone> Clone for ReadAtOffset<'a, T>"]], +"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_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>"]], "subspace_rpc_primitives":[["impl Clone for SolutionResponse"],["impl Clone for RewardSignatureResponse"],["impl Clone for FarmerAppInfo"],["impl Clone for NodeSyncStatus"],["impl Clone for SlotInfo"],["impl Clone for RewardSigningInfo"]], diff --git a/trait.impl/core/convert/trait.From.js b/trait.impl/core/convert/trait.From.js index f4a8af3bb3..e62a573aec 100644 --- a/trait.impl/core/convert/trait.From.js +++ b/trait.impl/core/convert/trait.From.js @@ -24,8 +24,8 @@ "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<PlottingError> for PlottingError"],["impl From<Ulid> for SingleDiskFarmId"],["impl From<FarmingError> for BackgroundTaskError"],["impl From<Error> for SingleDiskFarmError"],["impl From<PlottingError> for BackgroundTaskError"],["impl From<Error> for FarmingError"],["impl From<Box<dyn Error + Sync + Send>> for BackgroundTaskError"],["impl From<ProvingError> for FarmingError"],["impl From<Error> for PlottingError"],["impl From<ThreadPoolBuildError> for FarmingError"],["impl From<Error> for DiskPieceCacheError"]], -"subspace_farmer_components":[["impl From<Error> for ProvingError"],["impl From<Error> 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<SectorContentsMapFromBytesError> for ProvingError"],["impl From<SectorContentsMapFromBytesError> for ReadingError"],["impl From<ReadingError> for ProvingError"],["impl From<AcquireError> for PlottingError"]], +"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_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"]], "subspace_service":[["impl From<Error> for Error"],["impl From<AddrParseError> for Error"],["impl From<DsnConfigurationError> for Error"],["impl From<BlockRelayConfigurationError> for Error"],["impl From<SubstrateConfiguration> for Configuration"],["impl From<CreationError> for DsnConfigurationError"],["impl From<KnownPeersManagerPersistenceError> for DsnConfigurationError"],["impl From<Error> for Error"],["impl From<Error> for Error"],["impl From<Error> for Error"],["impl From<Error> for Error"]], diff --git a/trait.impl/core/error/trait.Error.js b/trait.impl/core/error/trait.Error.js index 9ee054ed3b..4802ab8ad3 100644 --- a/trait.impl/core/error/trait.Error.js +++ b/trait.impl/core/error/trait.Error.js @@ -4,8 +4,8 @@ "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 FarmingError"],["impl Error for Ss58ParsingError"],["impl Error for PlottingError"],["impl Error for BackgroundTaskError"],["impl Error for DiskPieceCacheError"],["impl Error for SingleDiskFarmError"],["impl Error for SingleDiskFarmScrubError"]], -"subspace_farmer_components":[["impl Error for ReadingError"],["impl Error for SectorContentsMapIterationError"],["impl Error for ProvingError"],["impl Error for SectorContentsMapFromBytesError"],["impl Error for PlottingError"],["impl Error for SectorContentsMapEncodeIntoError"]], +"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_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"]], "subspace_service":[["impl Error for DsnConfigurationError"],["impl Error for Error"]], diff --git a/trait.impl/core/fmt/trait.Debug.js b/trait.impl/core/fmt/trait.Debug.js index a44f4cb36c..bd12d9bd5d 100644 --- a/trait.impl/core/fmt/trait.Debug.js +++ b/trait.impl/core/fmt/trait.Debug.js @@ -38,8 +38,8 @@ "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 Ss58ParsingError"],["impl Debug for SingleDiskFarmError"],["impl Debug for AuditEvent"],["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 PlottingError"],["impl Debug for PlottingThreadPoolPair"],["impl Debug for Offset"],["impl Debug for SectorPlottingDetails"],["impl Debug for FarmingError"],["impl Debug for SingleDiskFarmInfo"],["impl Debug for DiskPieceCache"],["impl Debug for NodeRpcClient"],["impl Debug for ReadersAndPieces"],["impl Debug for SectorUpdate"],["impl Debug for SingleDiskFarmId"],["impl Debug for DiskPieceCacheError"],["impl Debug for PlottingThreadPoolManager"],["impl Debug for PieceReader"],["impl<'a, PosTable> Debug for PlotAuditOptions<'a, PosTable>
where\n PosTable: Table + Debug,\n PosTable::Generator: Debug,
"],["impl Debug for SingleDiskFarmScrubError"],["impl Debug for PlottingThreadPoolsGuard"],["impl Debug for SingleDiskFarmSummary"],["impl Debug for SectorExpirationDetails"]], -"subspace_farmer_components":[["impl Debug for SectorContentsMap"],["impl Debug for PlottingError"],["impl Debug for PlottedSector"],["impl Debug for FarmerProtocolInfo"],["impl Debug for SectorContentsMapIterationError"],["impl Debug for PieceGetterRetryPolicy"],["impl Debug for ProvingError"],["impl Debug for ReadingError"],["impl Debug for SectorMetadata"],["impl Debug for SectorContentsMapEncodeIntoError"],["impl<'a, Sector> Debug for SolutionCandidates<'a, Sector>
where\n Sector: 'a + Debug,
"],["impl Debug for SectorContentsMapFromBytesError"],["impl Debug for PlotRecord"],["impl Debug for SectorMetadataChecksummed"],["impl<'a, T: Debug> Debug for ReadAtOffset<'a, T>"],["impl<'a, Sector> Debug for AuditResult<'a, Sector>
where\n Sector: 'a + Debug,
"]], +"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_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"]], "subspace_proof_of_space":[["impl<const K: u8> Debug for Tables<K>
where\n EvaluatableUsize<{ _ }>: Sized,\n EvaluatableUsize<{ _ }>: Sized,\n EvaluatableUsize<{ _ }>: Sized,\n EvaluatableUsize<{ _ }>: Sized,\n EvaluatableUsize<{ _ }>: Sized,\n EvaluatableUsize<{ _ }>: Sized,\n EvaluatableUsize<{ _ }>: Sized,
"],["impl Debug for ChiaTableGenerator"],["impl Debug for ShimTable"],["impl<const K: u8> Debug for TablesCache<K>"],["impl Debug for ShimTableGenerator"],["impl Debug for ChiaTable"],["impl Debug for PosTableType"]], diff --git a/trait.impl/core/fmt/trait.Display.js b/trait.impl/core/fmt/trait.Display.js index 5f09b327db..291a330365 100644 --- a/trait.impl/core/fmt/trait.Display.js +++ b/trait.impl/core/fmt/trait.Display.js @@ -6,8 +6,8 @@ "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 FarmingError"],["impl Display for Offset"],["impl Display for Ss58ParsingError"],["impl Display for SingleDiskFarmError"],["impl Display for PlottingError"],["impl Display for BackgroundTaskError"],["impl Display for SingleDiskFarmId"],["impl Display for SingleDiskFarmScrubError"],["impl Display for DiskPieceCacheError"]], -"subspace_farmer_components":[["impl Display for SectorContentsMapEncodeIntoError"],["impl Display for SectorContentsMapFromBytesError"],["impl Display for ReadingError"],["impl Display for ProvingError"],["impl Display for SectorContentsMapIterationError"],["impl Display for PlottingError"]], +"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_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"]], "subspace_service":[["impl Display for Error"],["impl Display for DsnConfigurationError"]], diff --git a/trait.impl/core/marker/trait.Copy.js b/trait.impl/core/marker/trait.Copy.js index dd100967a8..ac58360f40 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 Copy for Offset"],["impl<'a, PosTable> Copy for PlotAuditOptions<'a, PosTable>
where\n PosTable: Table,
"],["impl Copy for SingleDiskFarmId"]], +"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_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.Freeze.js b/trait.impl/core/marker/trait.Freeze.js index efb6cbd54d..ecb1b1eba7 100644 --- a/trait.impl/core/marker/trait.Freeze.js +++ b/trait.impl/core/marker/trait.Freeze.js @@ -41,8 +41,8 @@ "subspace_archiving":[["impl Freeze for Segment",1,["subspace_archiving::archiver::Segment"]],["impl Freeze for SegmentItem",1,["subspace_archiving::archiver::SegmentItem"]],["impl Freeze for NewArchivedSegment",1,["subspace_archiving::archiver::NewArchivedSegment"]],["impl Freeze for ArchiverInstantiationError",1,["subspace_archiving::archiver::ArchiverInstantiationError"]],["impl Freeze for Archiver",1,["subspace_archiving::archiver::Archiver"]],["impl Freeze for ReconstructorInstantiationError",1,["subspace_archiving::piece_reconstructor::ReconstructorInstantiationError"]],["impl Freeze for ReconstructorError",1,["subspace_archiving::piece_reconstructor::ReconstructorError"]],["impl Freeze for PiecesReconstructor",1,["subspace_archiving::piece_reconstructor::PiecesReconstructor"]],["impl Freeze for ReconstructorInstantiationError",1,["subspace_archiving::reconstructor::ReconstructorInstantiationError"]],["impl Freeze for ReconstructorError",1,["subspace_archiving::reconstructor::ReconstructorError"]],["impl Freeze for ReconstructedContents",1,["subspace_archiving::reconstructor::ReconstructedContents"]],["impl Freeze for Reconstructor",1,["subspace_archiving::reconstructor::Reconstructor"]]], "subspace_core_primitives":[["impl<T> Freeze for Blake3Checksummed<T>
where\n T: Freeze,
",1,["subspace_core_primitives::checksum::Blake3Checksummed"]],["impl Freeze for Polynomial",1,["subspace_core_primitives::crypto::kzg::Polynomial"]],["impl Freeze for Commitment",1,["subspace_core_primitives::crypto::kzg::Commitment"]],["impl Freeze for Witness",1,["subspace_core_primitives::crypto::kzg::Witness"]],["impl Freeze for Kzg",1,["subspace_core_primitives::crypto::kzg::Kzg"]],["impl Freeze for Scalar",1,["subspace_core_primitives::crypto::Scalar"]],["impl Freeze for BlockObject",1,["subspace_core_primitives::objects::BlockObject"]],["impl Freeze for BlockObjectMapping",1,["subspace_core_primitives::objects::BlockObjectMapping"]],["impl Freeze for PieceObject",1,["subspace_core_primitives::objects::PieceObject"]],["impl Freeze for PieceObjectMapping",1,["subspace_core_primitives::objects::PieceObjectMapping"]],["impl Freeze for GlobalObject",1,["subspace_core_primitives::objects::GlobalObject"]],["impl Freeze for SBucket",1,["subspace_core_primitives::pieces::SBucket"]],["impl Freeze for PieceIndex",1,["subspace_core_primitives::pieces::PieceIndex"]],["impl Freeze for PieceOffset",1,["subspace_core_primitives::pieces::PieceOffset"]],["impl Freeze for RawRecord",1,["subspace_core_primitives::pieces::RawRecord"]],["impl Freeze for Record",1,["subspace_core_primitives::pieces::Record"]],["impl Freeze for RecordCommitment",1,["subspace_core_primitives::pieces::RecordCommitment"]],["impl Freeze for RecordWitness",1,["subspace_core_primitives::pieces::RecordWitness"]],["impl Freeze for ChunkWitness",1,["subspace_core_primitives::pieces::ChunkWitness"]],["impl Freeze for Piece",1,["subspace_core_primitives::pieces::Piece"]],["impl Freeze for PieceArray",1,["subspace_core_primitives::pieces::PieceArray"]],["impl Freeze for FlatPieces",1,["subspace_core_primitives::pieces::FlatPieces"]],["impl Freeze for SegmentIndex",1,["subspace_core_primitives::segments::SegmentIndex"]],["impl Freeze for SegmentCommitment",1,["subspace_core_primitives::segments::SegmentCommitment"]],["impl Freeze for HistorySize",1,["subspace_core_primitives::segments::HistorySize"]],["impl Freeze for RecordedHistorySegment",1,["subspace_core_primitives::segments::RecordedHistorySegment"]],["impl Freeze for ArchivedHistorySegment",1,["subspace_core_primitives::segments::ArchivedHistorySegment"]],["impl Freeze for Randomness",1,["subspace_core_primitives::Randomness"]],["impl Freeze for PosSeed",1,["subspace_core_primitives::PosSeed"]],["impl Freeze for PosProof",1,["subspace_core_primitives::PosProof"]],["impl Freeze for PotKey",1,["subspace_core_primitives::PotKey"]],["impl Freeze for PotSeed",1,["subspace_core_primitives::PotSeed"]],["impl Freeze for PotOutput",1,["subspace_core_primitives::PotOutput"]],["impl Freeze for PotCheckpoints",1,["subspace_core_primitives::PotCheckpoints"]],["impl Freeze for PublicKey",1,["subspace_core_primitives::PublicKey"]],["impl Freeze for RewardSignature",1,["subspace_core_primitives::RewardSignature"]],["impl Freeze for ArchivedBlockProgress",1,["subspace_core_primitives::ArchivedBlockProgress"]],["impl Freeze for LastArchivedBlock",1,["subspace_core_primitives::LastArchivedBlock"]],["impl Freeze for SegmentHeader",1,["subspace_core_primitives::SegmentHeader"]],["impl<PublicKey, RewardAddress> Freeze for Solution<PublicKey, RewardAddress>
where\n PublicKey: Freeze,\n RewardAddress: Freeze,
",1,["subspace_core_primitives::Solution"]],["impl Freeze for U256",1,["subspace_core_primitives::U256"]],["impl Freeze for SectorSlotChallenge",1,["subspace_core_primitives::SectorSlotChallenge"]],["impl Freeze for SectorId",1,["subspace_core_primitives::SectorId"]],["impl<T> Freeze for NonEmptyVec<T>",1,["subspace_core_primitives::NonEmptyVec"]],["impl Freeze for NonEmptyVecErr",1,["subspace_core_primitives::NonEmptyVecErr"]]], "subspace_erasure_coding":[["impl Freeze for ErasureCoding",1,["subspace_erasure_coding::ErasureCoding"]]], -"subspace_farmer":[["impl Freeze for Identity",1,["subspace_farmer::identity::Identity"]],["impl Freeze for NodeRpcClient",1,["subspace_farmer::node_client::node_rpc_client::NodeRpcClient"]],["impl<NC> Freeze for CacheWorker<NC>
where\n NC: Freeze,
",1,["subspace_farmer::piece_cache::CacheWorker"]],["impl Freeze for PieceCache",1,["subspace_farmer::piece_cache::PieceCache"]],["impl Freeze for RayonFiles",1,["subspace_farmer::single_disk_farm::farming::rayon_files::RayonFiles"]],["impl Freeze for AuditEvent",1,["subspace_farmer::single_disk_farm::farming::AuditEvent"]],["impl Freeze for FarmingError",1,["subspace_farmer::single_disk_farm::farming::FarmingError"]],["impl<'a, PosTable> Freeze for PlotAuditOptions<'a, PosTable>",1,["subspace_farmer::single_disk_farm::farming::PlotAuditOptions"]],["impl<Plot> Freeze for PlotAudit<Plot>
where\n Plot: Freeze,
",1,["subspace_farmer::single_disk_farm::farming::PlotAudit"]],["impl Freeze for DiskPieceCacheError",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"]],["impl Freeze for Offset",1,["subspace_farmer::single_disk_farm::piece_cache::Offset"]],["impl Freeze for DiskPieceCache",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCache"]],["impl Freeze for PieceReader",1,["subspace_farmer::single_disk_farm::piece_reader::PieceReader"]],["impl Freeze for PlottingError",1,["subspace_farmer::single_disk_farm::plotting::PlottingError"]],["impl Freeze for SingleDiskFarmId",1,["subspace_farmer::single_disk_farm::SingleDiskFarmId"]],["impl Freeze for SingleDiskFarmInfoLock",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock"]],["impl Freeze for SingleDiskFarmInfo",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfo"]],["impl Freeze for SingleDiskFarmSummary",1,["subspace_farmer::single_disk_farm::SingleDiskFarmSummary"]],["impl<NC, PG> Freeze for SingleDiskFarmOptions<NC, PG>
where\n NC: Freeze,\n PG: Freeze,
",1,["subspace_farmer::single_disk_farm::SingleDiskFarmOptions"]],["impl Freeze for SingleDiskFarmError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmError"]],["impl Freeze for SingleDiskFarmScrubError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"]],["impl Freeze for BackgroundTaskError",1,["subspace_farmer::single_disk_farm::BackgroundTaskError"]],["impl Freeze for SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::SectorPlottingDetails"]],["impl Freeze for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::SectorExpirationDetails"]],["impl Freeze for SectorUpdate",1,["subspace_farmer::single_disk_farm::SectorUpdate"]],["impl !Freeze for SingleDiskFarm",1,["subspace_farmer::single_disk_farm::SingleDiskFarm"]],["impl Freeze for PlottingThreadPoolPair",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolPair"]],["impl Freeze for PlottingThreadPoolsGuard",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolsGuard"]],["impl Freeze for PlottingThreadPoolManager",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolManager"]],["impl<PV, NC> Freeze for FarmerPieceGetter<PV, NC>
where\n NC: Freeze,\n PV: Freeze,
",1,["subspace_farmer::utils::farmer_piece_getter::FarmerPieceGetter"]],["impl<NC> Freeze for SegmentCommitmentPieceValidator<NC>
where\n NC: Freeze,
",1,["subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator"]],["impl Freeze for ReadersAndPieces",1,["subspace_farmer::utils::readers_and_pieces::ReadersAndPieces"]],["impl Freeze for Ss58ParsingError",1,["subspace_farmer::utils::ss58::Ss58ParsingError"]],["impl<T> Freeze for AsyncJoinOnDrop<T>",1,["subspace_farmer::utils::AsyncJoinOnDrop"]],["impl Freeze for CpuCoreSet",1,["subspace_farmer::utils::CpuCoreSet"]]], -"subspace_farmer_components":[["impl<'a, Sector> Freeze for AuditResult<'a, Sector>
where\n Sector: Freeze,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl Freeze for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl Freeze for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl Freeze for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> Freeze for PlotSectorOptions<'a, PosTable, PG>",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl Freeze for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> Freeze for DownloadSectorOptions<'a, PG>",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> Freeze for EncodeSectorOptions<'a, PosTable>",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl Freeze for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> Freeze for SolutionCandidates<'a, Sector>
where\n Sector: Freeze,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl Freeze for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl Freeze for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl Freeze for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl Freeze for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> Freeze for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl Freeze for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl Freeze for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl Freeze for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl Freeze for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> Freeze for ReadAt<S, A>
where\n A: Freeze,\n S: Freeze,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> Freeze for AsyncReadBytes<B>
where\n B: Freeze,
",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> Freeze for ReadAtOffset<'a, T>",1,["subspace_farmer_components::ReadAtOffset"]],["impl Freeze for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], +"subspace_farmer":[["impl Freeze for Identity",1,["subspace_farmer::identity::Identity"]],["impl Freeze for NodeRpcClient",1,["subspace_farmer::node_client::node_rpc_client::NodeRpcClient"]],["impl<NC> Freeze for CacheWorker<NC>
where\n NC: Freeze,
",1,["subspace_farmer::piece_cache::CacheWorker"]],["impl Freeze for PieceCache",1,["subspace_farmer::piece_cache::PieceCache"]],["impl Freeze for RayonFiles",1,["subspace_farmer::single_disk_farm::farming::rayon_files::RayonFiles"]],["impl Freeze for AuditingDetails",1,["subspace_farmer::single_disk_farm::farming::AuditingDetails"]],["impl Freeze for ProvingResult",1,["subspace_farmer::single_disk_farm::farming::ProvingResult"]],["impl Freeze for ProvingDetails",1,["subspace_farmer::single_disk_farm::farming::ProvingDetails"]],["impl Freeze for FarmingNotification",1,["subspace_farmer::single_disk_farm::farming::FarmingNotification"]],["impl Freeze for DecodedFarmingError",1,["subspace_farmer::single_disk_farm::farming::DecodedFarmingError"]],["impl Freeze for FarmingError",1,["subspace_farmer::single_disk_farm::farming::FarmingError"]],["impl<'a, PosTable> Freeze for PlotAuditOptions<'a, PosTable>",1,["subspace_farmer::single_disk_farm::farming::PlotAuditOptions"]],["impl<Plot> Freeze for PlotAudit<Plot>
where\n Plot: Freeze,
",1,["subspace_farmer::single_disk_farm::farming::PlotAudit"]],["impl Freeze for DiskPieceCacheError",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"]],["impl Freeze for Offset",1,["subspace_farmer::single_disk_farm::piece_cache::Offset"]],["impl Freeze for DiskPieceCache",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCache"]],["impl Freeze for PieceReader",1,["subspace_farmer::single_disk_farm::piece_reader::PieceReader"]],["impl Freeze for SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorPlottingDetails"]],["impl Freeze for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorExpirationDetails"]],["impl Freeze for PlottingError",1,["subspace_farmer::single_disk_farm::plotting::PlottingError"]],["impl Freeze for SingleDiskFarmId",1,["subspace_farmer::single_disk_farm::SingleDiskFarmId"]],["impl Freeze for SingleDiskFarmInfoLock",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock"]],["impl Freeze for SingleDiskFarmInfo",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfo"]],["impl Freeze for SingleDiskFarmSummary",1,["subspace_farmer::single_disk_farm::SingleDiskFarmSummary"]],["impl<NC, PG> Freeze for SingleDiskFarmOptions<NC, PG>
where\n NC: Freeze,\n PG: Freeze,
",1,["subspace_farmer::single_disk_farm::SingleDiskFarmOptions"]],["impl Freeze for SingleDiskFarmError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmError"]],["impl Freeze for SingleDiskFarmScrubError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"]],["impl Freeze for BackgroundTaskError",1,["subspace_farmer::single_disk_farm::BackgroundTaskError"]],["impl Freeze for SectorUpdate",1,["subspace_farmer::single_disk_farm::SectorUpdate"]],["impl !Freeze for SingleDiskFarm",1,["subspace_farmer::single_disk_farm::SingleDiskFarm"]],["impl Freeze for PlottingThreadPoolPair",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolPair"]],["impl Freeze for PlottingThreadPoolsGuard",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolsGuard"]],["impl Freeze for PlottingThreadPoolManager",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolManager"]],["impl<PV, NC> Freeze for FarmerPieceGetter<PV, NC>
where\n NC: Freeze,\n PV: Freeze,
",1,["subspace_farmer::utils::farmer_piece_getter::FarmerPieceGetter"]],["impl<NC> Freeze for SegmentCommitmentPieceValidator<NC>
where\n NC: Freeze,
",1,["subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator"]],["impl Freeze for ReadersAndPieces",1,["subspace_farmer::utils::readers_and_pieces::ReadersAndPieces"]],["impl Freeze for Ss58ParsingError",1,["subspace_farmer::utils::ss58::Ss58ParsingError"]],["impl<T> Freeze for AsyncJoinOnDrop<T>",1,["subspace_farmer::utils::AsyncJoinOnDrop"]],["impl Freeze for CpuCoreSet",1,["subspace_farmer::utils::CpuCoreSet"]]], +"subspace_farmer_components":[["impl Freeze for AuditingError",1,["subspace_farmer_components::auditing::AuditingError"]],["impl<'a, Sector> Freeze for AuditResult<'a, Sector>
where\n Sector: Freeze,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl Freeze for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl Freeze for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl Freeze for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> Freeze for PlotSectorOptions<'a, PosTable, PG>",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl Freeze for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> Freeze for DownloadSectorOptions<'a, PG>",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> Freeze for EncodeSectorOptions<'a, PosTable>",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl Freeze for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> Freeze for SolutionCandidates<'a, Sector>
where\n Sector: Freeze,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl Freeze for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl Freeze for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl Freeze for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl Freeze for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> Freeze for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl Freeze for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl Freeze for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl Freeze for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl Freeze for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> Freeze for ReadAt<S, A>
where\n A: Freeze,\n S: Freeze,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> Freeze for AsyncReadBytes<B>
where\n B: Freeze,
",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> Freeze for ReadAtOffset<'a, T>",1,["subspace_farmer_components::ReadAtOffset"]],["impl Freeze for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], "subspace_malicious_operator":[["impl<CNetwork> Freeze for DomainInstanceStarter<CNetwork>",1,["subspace_malicious_operator::malicious_domain_instance_starter::DomainInstanceStarter"]],["impl Freeze for Cli",1,["subspace_malicious_operator::Cli"]],["impl Freeze for DomainCli",1,["subspace_malicious_operator::DomainCli"]]], "subspace_metrics":[["impl Freeze for RegistryAdapter",1,["subspace_metrics::RegistryAdapter"]],["impl Freeze for metrics",1,["subspace_metrics::metrics"]]], "subspace_networking":[["impl Freeze for PeerAddressRemovedEvent",1,["subspace_networking::behavior::persistent_parameters::PeerAddressRemovedEvent"]],["impl Freeze for KnownPeersManagerConfig",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerConfig"]],["impl Freeze for KnownPeersManagerPersistenceError",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerPersistenceError"]],["impl Freeze for KnownPeersManager",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManager"]],["impl Freeze for KademliaMode",1,["subspace_networking::constructor::KademliaMode"]],["impl<LocalRecordProvider> Freeze for Config<LocalRecordProvider>
where\n LocalRecordProvider: Freeze,
",1,["subspace_networking::constructor::Config"]],["impl Freeze for CreationError",1,["subspace_networking::constructor::CreationError"]],["impl Freeze for TopicSubscription",1,["subspace_networking::node::TopicSubscription"]],["impl Freeze for GetClosestPeersError",1,["subspace_networking::node::GetClosestPeersError"]],["impl Freeze for SubscribeError",1,["subspace_networking::node::SubscribeError"]],["impl Freeze for SendRequestError",1,["subspace_networking::node::SendRequestError"]],["impl Freeze for Node",1,["subspace_networking::node::Node"]],["impl<LocalRecordProvider> !Freeze for NodeRunner<LocalRecordProvider>",1,["subspace_networking::node_runner::NodeRunner"]],["impl<Request> Freeze for GenericRequestHandler<Request>",1,["subspace_networking::protocols::request_response::handlers::generic_request_handler::GenericRequestHandler"]],["impl Freeze for PieceByIndexRequest",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexRequest"]],["impl Freeze for PieceByIndexResponse",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexResponse"]],["impl Freeze for SegmentHeaderRequest",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderRequest"]],["impl Freeze for SegmentHeaderResponse",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderResponse"]],["impl Freeze for PeerDiscovered",1,["subspace_networking::shared::PeerDiscovered"]],["impl Freeze for MultihashCode",1,["subspace_networking::utils::multihash::MultihashCode"]],["impl Freeze for NoPieceValidator",1,["subspace_networking::utils::piece_provider::NoPieceValidator"]],["impl Freeze for RetryPolicy",1,["subspace_networking::utils::piece_provider::RetryPolicy"]],["impl<PV> Freeze for PieceProvider<PV>
where\n PV: Freeze,
",1,["subspace_networking::utils::piece_provider::PieceProvider"]],["impl<T> Freeze for KeyWrapper<T>
where\n T: Freeze,
",1,["subspace_networking::utils::unique_record_binary_heap::KeyWrapper"]],["impl<K> Freeze for UniqueRecordBinaryHeap<K>",1,["subspace_networking::utils::unique_record_binary_heap::UniqueRecordBinaryHeap"]],["impl Freeze for SubspaceMetrics",1,["subspace_networking::utils::SubspaceMetrics"]]], diff --git a/trait.impl/core/marker/trait.Send.js b/trait.impl/core/marker/trait.Send.js index ffdb63522c..41a36436b7 100644 --- a/trait.impl/core/marker/trait.Send.js +++ b/trait.impl/core/marker/trait.Send.js @@ -41,8 +41,8 @@ "subspace_archiving":[["impl Send for Segment",1,["subspace_archiving::archiver::Segment"]],["impl Send for SegmentItem",1,["subspace_archiving::archiver::SegmentItem"]],["impl Send for NewArchivedSegment",1,["subspace_archiving::archiver::NewArchivedSegment"]],["impl Send for ArchiverInstantiationError",1,["subspace_archiving::archiver::ArchiverInstantiationError"]],["impl Send for Archiver",1,["subspace_archiving::archiver::Archiver"]],["impl Send for ReconstructorInstantiationError",1,["subspace_archiving::piece_reconstructor::ReconstructorInstantiationError"]],["impl Send for ReconstructorError",1,["subspace_archiving::piece_reconstructor::ReconstructorError"]],["impl Send for PiecesReconstructor",1,["subspace_archiving::piece_reconstructor::PiecesReconstructor"]],["impl Send for ReconstructorInstantiationError",1,["subspace_archiving::reconstructor::ReconstructorInstantiationError"]],["impl Send for ReconstructorError",1,["subspace_archiving::reconstructor::ReconstructorError"]],["impl Send for ReconstructedContents",1,["subspace_archiving::reconstructor::ReconstructedContents"]],["impl Send for Reconstructor",1,["subspace_archiving::reconstructor::Reconstructor"]]], "subspace_core_primitives":[["impl<T> Send for Blake3Checksummed<T>
where\n T: Send,
",1,["subspace_core_primitives::checksum::Blake3Checksummed"]],["impl Send for Polynomial",1,["subspace_core_primitives::crypto::kzg::Polynomial"]],["impl Send for Commitment",1,["subspace_core_primitives::crypto::kzg::Commitment"]],["impl Send for Witness",1,["subspace_core_primitives::crypto::kzg::Witness"]],["impl Send for Kzg",1,["subspace_core_primitives::crypto::kzg::Kzg"]],["impl Send for Scalar",1,["subspace_core_primitives::crypto::Scalar"]],["impl Send for BlockObject",1,["subspace_core_primitives::objects::BlockObject"]],["impl Send for BlockObjectMapping",1,["subspace_core_primitives::objects::BlockObjectMapping"]],["impl Send for PieceObject",1,["subspace_core_primitives::objects::PieceObject"]],["impl Send for PieceObjectMapping",1,["subspace_core_primitives::objects::PieceObjectMapping"]],["impl Send for GlobalObject",1,["subspace_core_primitives::objects::GlobalObject"]],["impl Send for SBucket",1,["subspace_core_primitives::pieces::SBucket"]],["impl Send for PieceIndex",1,["subspace_core_primitives::pieces::PieceIndex"]],["impl Send for PieceOffset",1,["subspace_core_primitives::pieces::PieceOffset"]],["impl Send for RawRecord",1,["subspace_core_primitives::pieces::RawRecord"]],["impl Send for Record",1,["subspace_core_primitives::pieces::Record"]],["impl Send for RecordCommitment",1,["subspace_core_primitives::pieces::RecordCommitment"]],["impl Send for RecordWitness",1,["subspace_core_primitives::pieces::RecordWitness"]],["impl Send for ChunkWitness",1,["subspace_core_primitives::pieces::ChunkWitness"]],["impl Send for Piece",1,["subspace_core_primitives::pieces::Piece"]],["impl Send for PieceArray",1,["subspace_core_primitives::pieces::PieceArray"]],["impl Send for FlatPieces",1,["subspace_core_primitives::pieces::FlatPieces"]],["impl Send for SegmentIndex",1,["subspace_core_primitives::segments::SegmentIndex"]],["impl Send for SegmentCommitment",1,["subspace_core_primitives::segments::SegmentCommitment"]],["impl Send for HistorySize",1,["subspace_core_primitives::segments::HistorySize"]],["impl Send for RecordedHistorySegment",1,["subspace_core_primitives::segments::RecordedHistorySegment"]],["impl Send for ArchivedHistorySegment",1,["subspace_core_primitives::segments::ArchivedHistorySegment"]],["impl Send for Randomness",1,["subspace_core_primitives::Randomness"]],["impl Send for PosSeed",1,["subspace_core_primitives::PosSeed"]],["impl Send for PosProof",1,["subspace_core_primitives::PosProof"]],["impl Send for PotKey",1,["subspace_core_primitives::PotKey"]],["impl Send for PotSeed",1,["subspace_core_primitives::PotSeed"]],["impl Send for PotOutput",1,["subspace_core_primitives::PotOutput"]],["impl Send for PotCheckpoints",1,["subspace_core_primitives::PotCheckpoints"]],["impl Send for PublicKey",1,["subspace_core_primitives::PublicKey"]],["impl Send for RewardSignature",1,["subspace_core_primitives::RewardSignature"]],["impl Send for ArchivedBlockProgress",1,["subspace_core_primitives::ArchivedBlockProgress"]],["impl Send for LastArchivedBlock",1,["subspace_core_primitives::LastArchivedBlock"]],["impl Send for SegmentHeader",1,["subspace_core_primitives::SegmentHeader"]],["impl<PublicKey, RewardAddress> Send for Solution<PublicKey, RewardAddress>
where\n PublicKey: Send,\n RewardAddress: Send,
",1,["subspace_core_primitives::Solution"]],["impl Send for U256",1,["subspace_core_primitives::U256"]],["impl Send for SectorSlotChallenge",1,["subspace_core_primitives::SectorSlotChallenge"]],["impl Send for SectorId",1,["subspace_core_primitives::SectorId"]],["impl<T> Send for NonEmptyVec<T>
where\n T: Send,
",1,["subspace_core_primitives::NonEmptyVec"]],["impl Send for NonEmptyVecErr",1,["subspace_core_primitives::NonEmptyVecErr"]]], "subspace_erasure_coding":[["impl Send for ErasureCoding",1,["subspace_erasure_coding::ErasureCoding"]]], -"subspace_farmer":[["impl Send for Identity",1,["subspace_farmer::identity::Identity"]],["impl Send for NodeRpcClient",1,["subspace_farmer::node_client::node_rpc_client::NodeRpcClient"]],["impl<NC> Send for CacheWorker<NC>
where\n NC: Send,
",1,["subspace_farmer::piece_cache::CacheWorker"]],["impl Send for PieceCache",1,["subspace_farmer::piece_cache::PieceCache"]],["impl Send for RayonFiles",1,["subspace_farmer::single_disk_farm::farming::rayon_files::RayonFiles"]],["impl Send for AuditEvent",1,["subspace_farmer::single_disk_farm::farming::AuditEvent"]],["impl Send for FarmingError",1,["subspace_farmer::single_disk_farm::farming::FarmingError"]],["impl<'a, PosTable> Send for PlotAuditOptions<'a, PosTable>",1,["subspace_farmer::single_disk_farm::farming::PlotAuditOptions"]],["impl<Plot> Send for PlotAudit<Plot>",1,["subspace_farmer::single_disk_farm::farming::PlotAudit"]],["impl Send for DiskPieceCacheError",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"]],["impl Send for Offset",1,["subspace_farmer::single_disk_farm::piece_cache::Offset"]],["impl Send for DiskPieceCache",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCache"]],["impl Send for PieceReader",1,["subspace_farmer::single_disk_farm::piece_reader::PieceReader"]],["impl Send for PlottingError",1,["subspace_farmer::single_disk_farm::plotting::PlottingError"]],["impl Send for SingleDiskFarmId",1,["subspace_farmer::single_disk_farm::SingleDiskFarmId"]],["impl Send for SingleDiskFarmInfoLock",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock"]],["impl Send for SingleDiskFarmInfo",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfo"]],["impl Send for SingleDiskFarmSummary",1,["subspace_farmer::single_disk_farm::SingleDiskFarmSummary"]],["impl<NC, PG> Send for SingleDiskFarmOptions<NC, PG>
where\n NC: Send,\n PG: Send,
",1,["subspace_farmer::single_disk_farm::SingleDiskFarmOptions"]],["impl Send for SingleDiskFarmError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmError"]],["impl Send for SingleDiskFarmScrubError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"]],["impl Send for BackgroundTaskError",1,["subspace_farmer::single_disk_farm::BackgroundTaskError"]],["impl Send for SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::SectorPlottingDetails"]],["impl Send for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::SectorExpirationDetails"]],["impl Send for SectorUpdate",1,["subspace_farmer::single_disk_farm::SectorUpdate"]],["impl Send for SingleDiskFarm",1,["subspace_farmer::single_disk_farm::SingleDiskFarm"]],["impl Send for PlottingThreadPoolPair",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolPair"]],["impl Send for PlottingThreadPoolsGuard",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolsGuard"]],["impl Send for PlottingThreadPoolManager",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolManager"]],["impl<PV, NC> Send for FarmerPieceGetter<PV, NC>
where\n NC: Send,\n PV: Send,
",1,["subspace_farmer::utils::farmer_piece_getter::FarmerPieceGetter"]],["impl<NC> Send for SegmentCommitmentPieceValidator<NC>
where\n NC: Send,
",1,["subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator"]],["impl Send for ReadersAndPieces",1,["subspace_farmer::utils::readers_and_pieces::ReadersAndPieces"]],["impl Send for Ss58ParsingError",1,["subspace_farmer::utils::ss58::Ss58ParsingError"]],["impl<T> Send for AsyncJoinOnDrop<T>
where\n T: Send,
",1,["subspace_farmer::utils::AsyncJoinOnDrop"]],["impl Send for CpuCoreSet",1,["subspace_farmer::utils::CpuCoreSet"]]], -"subspace_farmer_components":[["impl<'a, Sector> Send for AuditResult<'a, Sector>
where\n Sector: Send,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl Send for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl Send for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl Send for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> Send for PlotSectorOptions<'a, PosTable, PG>
where\n PG: Sync,
",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl Send for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> Send for DownloadSectorOptions<'a, PG>
where\n PG: Sync,
",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> Send for EncodeSectorOptions<'a, PosTable>",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl Send for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> Send for SolutionCandidates<'a, Sector>
where\n Sector: Send,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl Send for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl Send for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl Send for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl Send for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> Send for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl Send for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl Send for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl Send for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl Send for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> Send for ReadAt<S, A>
where\n A: Send,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> Send for AsyncReadBytes<B>
where\n B: Send,
",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> Send for ReadAtOffset<'a, T>
where\n T: Sync,
",1,["subspace_farmer_components::ReadAtOffset"]],["impl Send for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], +"subspace_farmer":[["impl Send for Identity",1,["subspace_farmer::identity::Identity"]],["impl Send for NodeRpcClient",1,["subspace_farmer::node_client::node_rpc_client::NodeRpcClient"]],["impl<NC> Send for CacheWorker<NC>
where\n NC: Send,
",1,["subspace_farmer::piece_cache::CacheWorker"]],["impl Send for PieceCache",1,["subspace_farmer::piece_cache::PieceCache"]],["impl Send for RayonFiles",1,["subspace_farmer::single_disk_farm::farming::rayon_files::RayonFiles"]],["impl Send for AuditingDetails",1,["subspace_farmer::single_disk_farm::farming::AuditingDetails"]],["impl Send for ProvingResult",1,["subspace_farmer::single_disk_farm::farming::ProvingResult"]],["impl Send for ProvingDetails",1,["subspace_farmer::single_disk_farm::farming::ProvingDetails"]],["impl Send for FarmingNotification",1,["subspace_farmer::single_disk_farm::farming::FarmingNotification"]],["impl Send for DecodedFarmingError",1,["subspace_farmer::single_disk_farm::farming::DecodedFarmingError"]],["impl Send for FarmingError",1,["subspace_farmer::single_disk_farm::farming::FarmingError"]],["impl<'a, PosTable> Send for PlotAuditOptions<'a, PosTable>",1,["subspace_farmer::single_disk_farm::farming::PlotAuditOptions"]],["impl<Plot> Send for PlotAudit<Plot>",1,["subspace_farmer::single_disk_farm::farming::PlotAudit"]],["impl Send for DiskPieceCacheError",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"]],["impl Send for Offset",1,["subspace_farmer::single_disk_farm::piece_cache::Offset"]],["impl Send for DiskPieceCache",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCache"]],["impl Send for PieceReader",1,["subspace_farmer::single_disk_farm::piece_reader::PieceReader"]],["impl Send for SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorPlottingDetails"]],["impl Send for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorExpirationDetails"]],["impl Send for PlottingError",1,["subspace_farmer::single_disk_farm::plotting::PlottingError"]],["impl Send for SingleDiskFarmId",1,["subspace_farmer::single_disk_farm::SingleDiskFarmId"]],["impl Send for SingleDiskFarmInfoLock",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock"]],["impl Send for SingleDiskFarmInfo",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfo"]],["impl Send for SingleDiskFarmSummary",1,["subspace_farmer::single_disk_farm::SingleDiskFarmSummary"]],["impl<NC, PG> Send for SingleDiskFarmOptions<NC, PG>
where\n NC: Send,\n PG: Send,
",1,["subspace_farmer::single_disk_farm::SingleDiskFarmOptions"]],["impl Send for SingleDiskFarmError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmError"]],["impl Send for SingleDiskFarmScrubError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"]],["impl Send for BackgroundTaskError",1,["subspace_farmer::single_disk_farm::BackgroundTaskError"]],["impl Send for SectorUpdate",1,["subspace_farmer::single_disk_farm::SectorUpdate"]],["impl Send for SingleDiskFarm",1,["subspace_farmer::single_disk_farm::SingleDiskFarm"]],["impl Send for PlottingThreadPoolPair",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolPair"]],["impl Send for PlottingThreadPoolsGuard",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolsGuard"]],["impl Send for PlottingThreadPoolManager",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolManager"]],["impl<PV, NC> Send for FarmerPieceGetter<PV, NC>
where\n NC: Send,\n PV: Send,
",1,["subspace_farmer::utils::farmer_piece_getter::FarmerPieceGetter"]],["impl<NC> Send for SegmentCommitmentPieceValidator<NC>
where\n NC: Send,
",1,["subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator"]],["impl Send for ReadersAndPieces",1,["subspace_farmer::utils::readers_and_pieces::ReadersAndPieces"]],["impl Send for Ss58ParsingError",1,["subspace_farmer::utils::ss58::Ss58ParsingError"]],["impl<T> Send for AsyncJoinOnDrop<T>
where\n T: Send,
",1,["subspace_farmer::utils::AsyncJoinOnDrop"]],["impl Send for CpuCoreSet",1,["subspace_farmer::utils::CpuCoreSet"]]], +"subspace_farmer_components":[["impl Send for AuditingError",1,["subspace_farmer_components::auditing::AuditingError"]],["impl<'a, Sector> Send for AuditResult<'a, Sector>
where\n Sector: Send,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl Send for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl Send for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl Send for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> Send for PlotSectorOptions<'a, PosTable, PG>
where\n PG: Sync,
",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl Send for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> Send for DownloadSectorOptions<'a, PG>
where\n PG: Sync,
",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> Send for EncodeSectorOptions<'a, PosTable>",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl Send for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> Send for SolutionCandidates<'a, Sector>
where\n Sector: Send,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl Send for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl Send for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl Send for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl Send for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> Send for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl Send for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl Send for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl Send for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl Send for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> Send for ReadAt<S, A>
where\n A: Send,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> Send for AsyncReadBytes<B>
where\n B: Send,
",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> Send for ReadAtOffset<'a, T>
where\n T: Sync,
",1,["subspace_farmer_components::ReadAtOffset"]],["impl Send for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], "subspace_malicious_operator":[["impl<CNetwork> Send for DomainInstanceStarter<CNetwork>
where\n CNetwork: Sync + Send,
",1,["subspace_malicious_operator::malicious_domain_instance_starter::DomainInstanceStarter"]],["impl Send for Cli",1,["subspace_malicious_operator::Cli"]],["impl Send for DomainCli",1,["subspace_malicious_operator::DomainCli"]]], "subspace_metrics":[["impl Send for RegistryAdapter",1,["subspace_metrics::RegistryAdapter"]],["impl Send for metrics",1,["subspace_metrics::metrics"]]], "subspace_networking":[["impl Send for PeerAddressRemovedEvent",1,["subspace_networking::behavior::persistent_parameters::PeerAddressRemovedEvent"]],["impl Send for KnownPeersManagerConfig",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerConfig"]],["impl Send for KnownPeersManagerPersistenceError",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerPersistenceError"]],["impl Send for KnownPeersManager",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManager"]],["impl Send for KademliaMode",1,["subspace_networking::constructor::KademliaMode"]],["impl<LocalRecordProvider> Send for Config<LocalRecordProvider>
where\n LocalRecordProvider: Send,
",1,["subspace_networking::constructor::Config"]],["impl Send for CreationError",1,["subspace_networking::constructor::CreationError"]],["impl Send for TopicSubscription",1,["subspace_networking::node::TopicSubscription"]],["impl Send for GetClosestPeersError",1,["subspace_networking::node::GetClosestPeersError"]],["impl Send for SubscribeError",1,["subspace_networking::node::SubscribeError"]],["impl Send for SendRequestError",1,["subspace_networking::node::SendRequestError"]],["impl Send for Node",1,["subspace_networking::node::Node"]],["impl<LocalRecordProvider> Send for NodeRunner<LocalRecordProvider>",1,["subspace_networking::node_runner::NodeRunner"]],["impl<Request> Send for GenericRequestHandler<Request>",1,["subspace_networking::protocols::request_response::handlers::generic_request_handler::GenericRequestHandler"]],["impl Send for PieceByIndexRequest",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexRequest"]],["impl Send for PieceByIndexResponse",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexResponse"]],["impl Send for SegmentHeaderRequest",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderRequest"]],["impl Send for SegmentHeaderResponse",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderResponse"]],["impl Send for PeerDiscovered",1,["subspace_networking::shared::PeerDiscovered"]],["impl Send for MultihashCode",1,["subspace_networking::utils::multihash::MultihashCode"]],["impl Send for NoPieceValidator",1,["subspace_networking::utils::piece_provider::NoPieceValidator"]],["impl Send for RetryPolicy",1,["subspace_networking::utils::piece_provider::RetryPolicy"]],["impl<PV> Send for PieceProvider<PV>
where\n PV: Send,
",1,["subspace_networking::utils::piece_provider::PieceProvider"]],["impl<T> Send for KeyWrapper<T>
where\n T: Send,
",1,["subspace_networking::utils::unique_record_binary_heap::KeyWrapper"]],["impl<K> Send for UniqueRecordBinaryHeap<K>
where\n K: Send,
",1,["subspace_networking::utils::unique_record_binary_heap::UniqueRecordBinaryHeap"]],["impl Send for SubspaceMetrics",1,["subspace_networking::utils::SubspaceMetrics"]]], diff --git a/trait.impl/core/marker/trait.Sync.js b/trait.impl/core/marker/trait.Sync.js index 5e7d73e3b5..a56031372f 100644 --- a/trait.impl/core/marker/trait.Sync.js +++ b/trait.impl/core/marker/trait.Sync.js @@ -41,8 +41,8 @@ "subspace_archiving":[["impl Sync for Segment",1,["subspace_archiving::archiver::Segment"]],["impl Sync for SegmentItem",1,["subspace_archiving::archiver::SegmentItem"]],["impl Sync for NewArchivedSegment",1,["subspace_archiving::archiver::NewArchivedSegment"]],["impl Sync for ArchiverInstantiationError",1,["subspace_archiving::archiver::ArchiverInstantiationError"]],["impl Sync for Archiver",1,["subspace_archiving::archiver::Archiver"]],["impl Sync for ReconstructorInstantiationError",1,["subspace_archiving::piece_reconstructor::ReconstructorInstantiationError"]],["impl Sync for ReconstructorError",1,["subspace_archiving::piece_reconstructor::ReconstructorError"]],["impl Sync for PiecesReconstructor",1,["subspace_archiving::piece_reconstructor::PiecesReconstructor"]],["impl Sync for ReconstructorInstantiationError",1,["subspace_archiving::reconstructor::ReconstructorInstantiationError"]],["impl Sync for ReconstructorError",1,["subspace_archiving::reconstructor::ReconstructorError"]],["impl Sync for ReconstructedContents",1,["subspace_archiving::reconstructor::ReconstructedContents"]],["impl Sync for Reconstructor",1,["subspace_archiving::reconstructor::Reconstructor"]]], "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 AuditEvent",1,["subspace_farmer::single_disk_farm::farming::AuditEvent"]],["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 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 SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::SectorPlottingDetails"]],["impl Sync for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::SectorExpirationDetails"]],["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<'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":[["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_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/marker/trait.Unpin.js b/trait.impl/core/marker/trait.Unpin.js index 4924f948e8..cc18cb4ca8 100644 --- a/trait.impl/core/marker/trait.Unpin.js +++ b/trait.impl/core/marker/trait.Unpin.js @@ -41,8 +41,8 @@ "subspace_archiving":[["impl Unpin for Segment",1,["subspace_archiving::archiver::Segment"]],["impl Unpin for SegmentItem",1,["subspace_archiving::archiver::SegmentItem"]],["impl Unpin for NewArchivedSegment",1,["subspace_archiving::archiver::NewArchivedSegment"]],["impl Unpin for ArchiverInstantiationError",1,["subspace_archiving::archiver::ArchiverInstantiationError"]],["impl Unpin for Archiver",1,["subspace_archiving::archiver::Archiver"]],["impl Unpin for ReconstructorInstantiationError",1,["subspace_archiving::piece_reconstructor::ReconstructorInstantiationError"]],["impl Unpin for ReconstructorError",1,["subspace_archiving::piece_reconstructor::ReconstructorError"]],["impl Unpin for PiecesReconstructor",1,["subspace_archiving::piece_reconstructor::PiecesReconstructor"]],["impl Unpin for ReconstructorInstantiationError",1,["subspace_archiving::reconstructor::ReconstructorInstantiationError"]],["impl Unpin for ReconstructorError",1,["subspace_archiving::reconstructor::ReconstructorError"]],["impl Unpin for ReconstructedContents",1,["subspace_archiving::reconstructor::ReconstructedContents"]],["impl Unpin for Reconstructor",1,["subspace_archiving::reconstructor::Reconstructor"]]], "subspace_core_primitives":[["impl<T> Unpin for Blake3Checksummed<T>
where\n T: Unpin,
",1,["subspace_core_primitives::checksum::Blake3Checksummed"]],["impl Unpin for Polynomial",1,["subspace_core_primitives::crypto::kzg::Polynomial"]],["impl Unpin for Commitment",1,["subspace_core_primitives::crypto::kzg::Commitment"]],["impl Unpin for Witness",1,["subspace_core_primitives::crypto::kzg::Witness"]],["impl Unpin for Kzg",1,["subspace_core_primitives::crypto::kzg::Kzg"]],["impl Unpin for Scalar",1,["subspace_core_primitives::crypto::Scalar"]],["impl Unpin for BlockObject",1,["subspace_core_primitives::objects::BlockObject"]],["impl Unpin for BlockObjectMapping",1,["subspace_core_primitives::objects::BlockObjectMapping"]],["impl Unpin for PieceObject",1,["subspace_core_primitives::objects::PieceObject"]],["impl Unpin for PieceObjectMapping",1,["subspace_core_primitives::objects::PieceObjectMapping"]],["impl Unpin for GlobalObject",1,["subspace_core_primitives::objects::GlobalObject"]],["impl Unpin for SBucket",1,["subspace_core_primitives::pieces::SBucket"]],["impl Unpin for PieceIndex",1,["subspace_core_primitives::pieces::PieceIndex"]],["impl Unpin for PieceOffset",1,["subspace_core_primitives::pieces::PieceOffset"]],["impl Unpin for RawRecord",1,["subspace_core_primitives::pieces::RawRecord"]],["impl Unpin for Record",1,["subspace_core_primitives::pieces::Record"]],["impl Unpin for RecordCommitment",1,["subspace_core_primitives::pieces::RecordCommitment"]],["impl Unpin for RecordWitness",1,["subspace_core_primitives::pieces::RecordWitness"]],["impl Unpin for ChunkWitness",1,["subspace_core_primitives::pieces::ChunkWitness"]],["impl Unpin for Piece",1,["subspace_core_primitives::pieces::Piece"]],["impl Unpin for PieceArray",1,["subspace_core_primitives::pieces::PieceArray"]],["impl Unpin for FlatPieces",1,["subspace_core_primitives::pieces::FlatPieces"]],["impl Unpin for SegmentIndex",1,["subspace_core_primitives::segments::SegmentIndex"]],["impl Unpin for SegmentCommitment",1,["subspace_core_primitives::segments::SegmentCommitment"]],["impl Unpin for HistorySize",1,["subspace_core_primitives::segments::HistorySize"]],["impl Unpin for RecordedHistorySegment",1,["subspace_core_primitives::segments::RecordedHistorySegment"]],["impl Unpin for ArchivedHistorySegment",1,["subspace_core_primitives::segments::ArchivedHistorySegment"]],["impl Unpin for Randomness",1,["subspace_core_primitives::Randomness"]],["impl Unpin for PosSeed",1,["subspace_core_primitives::PosSeed"]],["impl Unpin for PosProof",1,["subspace_core_primitives::PosProof"]],["impl Unpin for PotKey",1,["subspace_core_primitives::PotKey"]],["impl Unpin for PotSeed",1,["subspace_core_primitives::PotSeed"]],["impl Unpin for PotOutput",1,["subspace_core_primitives::PotOutput"]],["impl Unpin for PotCheckpoints",1,["subspace_core_primitives::PotCheckpoints"]],["impl Unpin for PublicKey",1,["subspace_core_primitives::PublicKey"]],["impl Unpin for RewardSignature",1,["subspace_core_primitives::RewardSignature"]],["impl Unpin for ArchivedBlockProgress",1,["subspace_core_primitives::ArchivedBlockProgress"]],["impl Unpin for LastArchivedBlock",1,["subspace_core_primitives::LastArchivedBlock"]],["impl Unpin for SegmentHeader",1,["subspace_core_primitives::SegmentHeader"]],["impl<PublicKey, RewardAddress> Unpin for Solution<PublicKey, RewardAddress>
where\n PublicKey: Unpin,\n RewardAddress: Unpin,
",1,["subspace_core_primitives::Solution"]],["impl Unpin for U256",1,["subspace_core_primitives::U256"]],["impl Unpin for SectorSlotChallenge",1,["subspace_core_primitives::SectorSlotChallenge"]],["impl Unpin for SectorId",1,["subspace_core_primitives::SectorId"]],["impl<T> Unpin for NonEmptyVec<T>
where\n T: Unpin,
",1,["subspace_core_primitives::NonEmptyVec"]],["impl Unpin for NonEmptyVecErr",1,["subspace_core_primitives::NonEmptyVecErr"]]], "subspace_erasure_coding":[["impl Unpin for ErasureCoding",1,["subspace_erasure_coding::ErasureCoding"]]], -"subspace_farmer":[["impl Unpin for Identity",1,["subspace_farmer::identity::Identity"]],["impl Unpin for NodeRpcClient",1,["subspace_farmer::node_client::node_rpc_client::NodeRpcClient"]],["impl<NC> Unpin for CacheWorker<NC>
where\n NC: Unpin,
",1,["subspace_farmer::piece_cache::CacheWorker"]],["impl Unpin for PieceCache",1,["subspace_farmer::piece_cache::PieceCache"]],["impl Unpin for RayonFiles",1,["subspace_farmer::single_disk_farm::farming::rayon_files::RayonFiles"]],["impl Unpin for AuditEvent",1,["subspace_farmer::single_disk_farm::farming::AuditEvent"]],["impl Unpin for FarmingError",1,["subspace_farmer::single_disk_farm::farming::FarmingError"]],["impl<'a, PosTable> Unpin for PlotAuditOptions<'a, PosTable>",1,["subspace_farmer::single_disk_farm::farming::PlotAuditOptions"]],["impl<Plot> Unpin for PlotAudit<Plot>
where\n Plot: Unpin,
",1,["subspace_farmer::single_disk_farm::farming::PlotAudit"]],["impl Unpin for DiskPieceCacheError",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"]],["impl Unpin for Offset",1,["subspace_farmer::single_disk_farm::piece_cache::Offset"]],["impl Unpin for DiskPieceCache",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCache"]],["impl Unpin for PieceReader",1,["subspace_farmer::single_disk_farm::piece_reader::PieceReader"]],["impl Unpin for PlottingError",1,["subspace_farmer::single_disk_farm::plotting::PlottingError"]],["impl Unpin for SingleDiskFarmId",1,["subspace_farmer::single_disk_farm::SingleDiskFarmId"]],["impl Unpin for SingleDiskFarmInfoLock",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock"]],["impl Unpin for SingleDiskFarmInfo",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfo"]],["impl Unpin for SingleDiskFarmSummary",1,["subspace_farmer::single_disk_farm::SingleDiskFarmSummary"]],["impl<NC, PG> Unpin for SingleDiskFarmOptions<NC, PG>
where\n NC: Unpin,\n PG: Unpin,
",1,["subspace_farmer::single_disk_farm::SingleDiskFarmOptions"]],["impl Unpin for SingleDiskFarmError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmError"]],["impl Unpin for SingleDiskFarmScrubError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"]],["impl Unpin for BackgroundTaskError",1,["subspace_farmer::single_disk_farm::BackgroundTaskError"]],["impl Unpin for SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::SectorPlottingDetails"]],["impl Unpin for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::SectorExpirationDetails"]],["impl Unpin for SectorUpdate",1,["subspace_farmer::single_disk_farm::SectorUpdate"]],["impl Unpin for SingleDiskFarm",1,["subspace_farmer::single_disk_farm::SingleDiskFarm"]],["impl Unpin for PlottingThreadPoolPair",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolPair"]],["impl Unpin for PlottingThreadPoolsGuard",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolsGuard"]],["impl Unpin for PlottingThreadPoolManager",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolManager"]],["impl<PV, NC> Unpin for FarmerPieceGetter<PV, NC>
where\n NC: Unpin,\n PV: Unpin,
",1,["subspace_farmer::utils::farmer_piece_getter::FarmerPieceGetter"]],["impl<NC> Unpin for SegmentCommitmentPieceValidator<NC>
where\n NC: Unpin,
",1,["subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator"]],["impl Unpin for ReadersAndPieces",1,["subspace_farmer::utils::readers_and_pieces::ReadersAndPieces"]],["impl Unpin for Ss58ParsingError",1,["subspace_farmer::utils::ss58::Ss58ParsingError"]],["impl<T> Unpin for AsyncJoinOnDrop<T>",1,["subspace_farmer::utils::AsyncJoinOnDrop"]],["impl Unpin for CpuCoreSet",1,["subspace_farmer::utils::CpuCoreSet"]]], -"subspace_farmer_components":[["impl<'a, Sector> Unpin for AuditResult<'a, Sector>
where\n Sector: Unpin,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl Unpin for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl Unpin for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl Unpin for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> Unpin for PlotSectorOptions<'a, PosTable, PG>",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl Unpin for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> Unpin for DownloadSectorOptions<'a, PG>",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> Unpin for EncodeSectorOptions<'a, PosTable>",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl Unpin for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> Unpin for SolutionCandidates<'a, Sector>
where\n Sector: Unpin,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl Unpin for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl Unpin for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl Unpin for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl Unpin for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> Unpin for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl Unpin for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl Unpin for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl Unpin for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl Unpin for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> Unpin for ReadAt<S, A>
where\n A: Unpin,\n S: Unpin,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> Unpin for AsyncReadBytes<B>",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> Unpin for ReadAtOffset<'a, T>",1,["subspace_farmer_components::ReadAtOffset"]],["impl Unpin for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], +"subspace_farmer":[["impl Unpin for Identity",1,["subspace_farmer::identity::Identity"]],["impl Unpin for NodeRpcClient",1,["subspace_farmer::node_client::node_rpc_client::NodeRpcClient"]],["impl<NC> Unpin for CacheWorker<NC>
where\n NC: Unpin,
",1,["subspace_farmer::piece_cache::CacheWorker"]],["impl Unpin for PieceCache",1,["subspace_farmer::piece_cache::PieceCache"]],["impl Unpin for RayonFiles",1,["subspace_farmer::single_disk_farm::farming::rayon_files::RayonFiles"]],["impl Unpin for AuditingDetails",1,["subspace_farmer::single_disk_farm::farming::AuditingDetails"]],["impl Unpin for ProvingResult",1,["subspace_farmer::single_disk_farm::farming::ProvingResult"]],["impl Unpin for ProvingDetails",1,["subspace_farmer::single_disk_farm::farming::ProvingDetails"]],["impl Unpin for FarmingNotification",1,["subspace_farmer::single_disk_farm::farming::FarmingNotification"]],["impl Unpin for DecodedFarmingError",1,["subspace_farmer::single_disk_farm::farming::DecodedFarmingError"]],["impl Unpin for FarmingError",1,["subspace_farmer::single_disk_farm::farming::FarmingError"]],["impl<'a, PosTable> Unpin for PlotAuditOptions<'a, PosTable>",1,["subspace_farmer::single_disk_farm::farming::PlotAuditOptions"]],["impl<Plot> Unpin for PlotAudit<Plot>
where\n Plot: Unpin,
",1,["subspace_farmer::single_disk_farm::farming::PlotAudit"]],["impl Unpin for DiskPieceCacheError",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"]],["impl Unpin for Offset",1,["subspace_farmer::single_disk_farm::piece_cache::Offset"]],["impl Unpin for DiskPieceCache",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCache"]],["impl Unpin for PieceReader",1,["subspace_farmer::single_disk_farm::piece_reader::PieceReader"]],["impl Unpin for SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorPlottingDetails"]],["impl Unpin for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorExpirationDetails"]],["impl Unpin for PlottingError",1,["subspace_farmer::single_disk_farm::plotting::PlottingError"]],["impl Unpin for SingleDiskFarmId",1,["subspace_farmer::single_disk_farm::SingleDiskFarmId"]],["impl Unpin for SingleDiskFarmInfoLock",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock"]],["impl Unpin for SingleDiskFarmInfo",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfo"]],["impl Unpin for SingleDiskFarmSummary",1,["subspace_farmer::single_disk_farm::SingleDiskFarmSummary"]],["impl<NC, PG> Unpin for SingleDiskFarmOptions<NC, PG>
where\n NC: Unpin,\n PG: Unpin,
",1,["subspace_farmer::single_disk_farm::SingleDiskFarmOptions"]],["impl Unpin for SingleDiskFarmError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmError"]],["impl Unpin for SingleDiskFarmScrubError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"]],["impl Unpin for BackgroundTaskError",1,["subspace_farmer::single_disk_farm::BackgroundTaskError"]],["impl Unpin for SectorUpdate",1,["subspace_farmer::single_disk_farm::SectorUpdate"]],["impl Unpin for SingleDiskFarm",1,["subspace_farmer::single_disk_farm::SingleDiskFarm"]],["impl Unpin for PlottingThreadPoolPair",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolPair"]],["impl Unpin for PlottingThreadPoolsGuard",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolsGuard"]],["impl Unpin for PlottingThreadPoolManager",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolManager"]],["impl<PV, NC> Unpin for FarmerPieceGetter<PV, NC>
where\n NC: Unpin,\n PV: Unpin,
",1,["subspace_farmer::utils::farmer_piece_getter::FarmerPieceGetter"]],["impl<NC> Unpin for SegmentCommitmentPieceValidator<NC>
where\n NC: Unpin,
",1,["subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator"]],["impl Unpin for ReadersAndPieces",1,["subspace_farmer::utils::readers_and_pieces::ReadersAndPieces"]],["impl Unpin for Ss58ParsingError",1,["subspace_farmer::utils::ss58::Ss58ParsingError"]],["impl<T> Unpin for AsyncJoinOnDrop<T>",1,["subspace_farmer::utils::AsyncJoinOnDrop"]],["impl Unpin for CpuCoreSet",1,["subspace_farmer::utils::CpuCoreSet"]]], +"subspace_farmer_components":[["impl Unpin for AuditingError",1,["subspace_farmer_components::auditing::AuditingError"]],["impl<'a, Sector> Unpin for AuditResult<'a, Sector>
where\n Sector: Unpin,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl Unpin for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl Unpin for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl Unpin for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> Unpin for PlotSectorOptions<'a, PosTable, PG>",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl Unpin for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> Unpin for DownloadSectorOptions<'a, PG>",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> Unpin for EncodeSectorOptions<'a, PosTable>",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl Unpin for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> Unpin for SolutionCandidates<'a, Sector>
where\n Sector: Unpin,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl Unpin for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl Unpin for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl Unpin for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl Unpin for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> Unpin for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl Unpin for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl Unpin for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl Unpin for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl Unpin for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> Unpin for ReadAt<S, A>
where\n A: Unpin,\n S: Unpin,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> Unpin for AsyncReadBytes<B>",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> Unpin for ReadAtOffset<'a, T>",1,["subspace_farmer_components::ReadAtOffset"]],["impl Unpin for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], "subspace_malicious_operator":[["impl<CNetwork> Unpin for DomainInstanceStarter<CNetwork>",1,["subspace_malicious_operator::malicious_domain_instance_starter::DomainInstanceStarter"]],["impl Unpin for Cli",1,["subspace_malicious_operator::Cli"]],["impl Unpin for DomainCli",1,["subspace_malicious_operator::DomainCli"]]], "subspace_metrics":[["impl Unpin for RegistryAdapter",1,["subspace_metrics::RegistryAdapter"]],["impl Unpin for metrics",1,["subspace_metrics::metrics"]]], "subspace_networking":[["impl Unpin for PeerAddressRemovedEvent",1,["subspace_networking::behavior::persistent_parameters::PeerAddressRemovedEvent"]],["impl Unpin for KnownPeersManagerConfig",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerConfig"]],["impl Unpin for KnownPeersManagerPersistenceError",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerPersistenceError"]],["impl Unpin for KnownPeersManager",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManager"]],["impl Unpin for KademliaMode",1,["subspace_networking::constructor::KademliaMode"]],["impl<LocalRecordProvider> Unpin for Config<LocalRecordProvider>
where\n LocalRecordProvider: Unpin,
",1,["subspace_networking::constructor::Config"]],["impl Unpin for CreationError",1,["subspace_networking::constructor::CreationError"]],["impl Unpin for GetClosestPeersError",1,["subspace_networking::node::GetClosestPeersError"]],["impl Unpin for SubscribeError",1,["subspace_networking::node::SubscribeError"]],["impl Unpin for SendRequestError",1,["subspace_networking::node::SendRequestError"]],["impl Unpin for Node",1,["subspace_networking::node::Node"]],["impl<LocalRecordProvider> Unpin for NodeRunner<LocalRecordProvider>",1,["subspace_networking::node_runner::NodeRunner"]],["impl<Request> Unpin for GenericRequestHandler<Request>",1,["subspace_networking::protocols::request_response::handlers::generic_request_handler::GenericRequestHandler"]],["impl Unpin for PieceByIndexRequest",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexRequest"]],["impl Unpin for PieceByIndexResponse",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexResponse"]],["impl Unpin for SegmentHeaderRequest",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderRequest"]],["impl Unpin for SegmentHeaderResponse",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderResponse"]],["impl Unpin for PeerDiscovered",1,["subspace_networking::shared::PeerDiscovered"]],["impl Unpin for MultihashCode",1,["subspace_networking::utils::multihash::MultihashCode"]],["impl Unpin for NoPieceValidator",1,["subspace_networking::utils::piece_provider::NoPieceValidator"]],["impl Unpin for RetryPolicy",1,["subspace_networking::utils::piece_provider::RetryPolicy"]],["impl<PV> Unpin for PieceProvider<PV>
where\n PV: Unpin,
",1,["subspace_networking::utils::piece_provider::PieceProvider"]],["impl<T> Unpin for KeyWrapper<T>
where\n T: Unpin,
",1,["subspace_networking::utils::unique_record_binary_heap::KeyWrapper"]],["impl<K> Unpin for UniqueRecordBinaryHeap<K>",1,["subspace_networking::utils::unique_record_binary_heap::UniqueRecordBinaryHeap"]],["impl Unpin for SubspaceMetrics",1,["subspace_networking::utils::SubspaceMetrics"]],["impl<'pin> Unpin for TopicSubscription
where\n __TopicSubscription<'pin>: Unpin,
"]], diff --git a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js index 72695e1d01..26f0ff50d6 100644 --- a/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js +++ b/trait.impl/core/panic/unwind_safe/trait.RefUnwindSafe.js @@ -41,8 +41,8 @@ "subspace_archiving":[["impl RefUnwindSafe for Segment",1,["subspace_archiving::archiver::Segment"]],["impl RefUnwindSafe for SegmentItem",1,["subspace_archiving::archiver::SegmentItem"]],["impl RefUnwindSafe for NewArchivedSegment",1,["subspace_archiving::archiver::NewArchivedSegment"]],["impl RefUnwindSafe for ArchiverInstantiationError",1,["subspace_archiving::archiver::ArchiverInstantiationError"]],["impl !RefUnwindSafe for Archiver",1,["subspace_archiving::archiver::Archiver"]],["impl RefUnwindSafe for ReconstructorInstantiationError",1,["subspace_archiving::piece_reconstructor::ReconstructorInstantiationError"]],["impl RefUnwindSafe for ReconstructorError",1,["subspace_archiving::piece_reconstructor::ReconstructorError"]],["impl !RefUnwindSafe for PiecesReconstructor",1,["subspace_archiving::piece_reconstructor::PiecesReconstructor"]],["impl RefUnwindSafe for ReconstructorInstantiationError",1,["subspace_archiving::reconstructor::ReconstructorInstantiationError"]],["impl RefUnwindSafe for ReconstructorError",1,["subspace_archiving::reconstructor::ReconstructorError"]],["impl RefUnwindSafe for ReconstructedContents",1,["subspace_archiving::reconstructor::ReconstructedContents"]],["impl RefUnwindSafe for Reconstructor",1,["subspace_archiving::reconstructor::Reconstructor"]]], "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 AuditEvent",1,["subspace_farmer::single_disk_farm::farming::AuditEvent"]],["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 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 SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::SectorPlottingDetails"]],["impl RefUnwindSafe for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::SectorExpirationDetails"]],["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<'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":[["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_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/core/panic/unwind_safe/trait.UnwindSafe.js b/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js index 7d96cdfdf1..99f861a777 100644 --- a/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js +++ b/trait.impl/core/panic/unwind_safe/trait.UnwindSafe.js @@ -41,8 +41,8 @@ "subspace_archiving":[["impl UnwindSafe for Segment",1,["subspace_archiving::archiver::Segment"]],["impl UnwindSafe for SegmentItem",1,["subspace_archiving::archiver::SegmentItem"]],["impl UnwindSafe for NewArchivedSegment",1,["subspace_archiving::archiver::NewArchivedSegment"]],["impl UnwindSafe for ArchiverInstantiationError",1,["subspace_archiving::archiver::ArchiverInstantiationError"]],["impl !UnwindSafe for Archiver",1,["subspace_archiving::archiver::Archiver"]],["impl UnwindSafe for ReconstructorInstantiationError",1,["subspace_archiving::piece_reconstructor::ReconstructorInstantiationError"]],["impl UnwindSafe for ReconstructorError",1,["subspace_archiving::piece_reconstructor::ReconstructorError"]],["impl !UnwindSafe for PiecesReconstructor",1,["subspace_archiving::piece_reconstructor::PiecesReconstructor"]],["impl UnwindSafe for ReconstructorInstantiationError",1,["subspace_archiving::reconstructor::ReconstructorInstantiationError"]],["impl UnwindSafe for ReconstructorError",1,["subspace_archiving::reconstructor::ReconstructorError"]],["impl UnwindSafe for ReconstructedContents",1,["subspace_archiving::reconstructor::ReconstructedContents"]],["impl UnwindSafe for Reconstructor",1,["subspace_archiving::reconstructor::Reconstructor"]]], "subspace_core_primitives":[["impl<T> UnwindSafe for Blake3Checksummed<T>
where\n T: UnwindSafe,
",1,["subspace_core_primitives::checksum::Blake3Checksummed"]],["impl UnwindSafe for Polynomial",1,["subspace_core_primitives::crypto::kzg::Polynomial"]],["impl UnwindSafe for Commitment",1,["subspace_core_primitives::crypto::kzg::Commitment"]],["impl UnwindSafe for Witness",1,["subspace_core_primitives::crypto::kzg::Witness"]],["impl !UnwindSafe for Kzg",1,["subspace_core_primitives::crypto::kzg::Kzg"]],["impl UnwindSafe for Scalar",1,["subspace_core_primitives::crypto::Scalar"]],["impl UnwindSafe for BlockObject",1,["subspace_core_primitives::objects::BlockObject"]],["impl UnwindSafe for BlockObjectMapping",1,["subspace_core_primitives::objects::BlockObjectMapping"]],["impl UnwindSafe for PieceObject",1,["subspace_core_primitives::objects::PieceObject"]],["impl UnwindSafe for PieceObjectMapping",1,["subspace_core_primitives::objects::PieceObjectMapping"]],["impl UnwindSafe for GlobalObject",1,["subspace_core_primitives::objects::GlobalObject"]],["impl UnwindSafe for SBucket",1,["subspace_core_primitives::pieces::SBucket"]],["impl UnwindSafe for PieceIndex",1,["subspace_core_primitives::pieces::PieceIndex"]],["impl UnwindSafe for PieceOffset",1,["subspace_core_primitives::pieces::PieceOffset"]],["impl UnwindSafe for RawRecord",1,["subspace_core_primitives::pieces::RawRecord"]],["impl UnwindSafe for Record",1,["subspace_core_primitives::pieces::Record"]],["impl UnwindSafe for RecordCommitment",1,["subspace_core_primitives::pieces::RecordCommitment"]],["impl UnwindSafe for RecordWitness",1,["subspace_core_primitives::pieces::RecordWitness"]],["impl UnwindSafe for ChunkWitness",1,["subspace_core_primitives::pieces::ChunkWitness"]],["impl UnwindSafe for Piece",1,["subspace_core_primitives::pieces::Piece"]],["impl UnwindSafe for PieceArray",1,["subspace_core_primitives::pieces::PieceArray"]],["impl UnwindSafe for FlatPieces",1,["subspace_core_primitives::pieces::FlatPieces"]],["impl UnwindSafe for SegmentIndex",1,["subspace_core_primitives::segments::SegmentIndex"]],["impl UnwindSafe for SegmentCommitment",1,["subspace_core_primitives::segments::SegmentCommitment"]],["impl UnwindSafe for HistorySize",1,["subspace_core_primitives::segments::HistorySize"]],["impl UnwindSafe for RecordedHistorySegment",1,["subspace_core_primitives::segments::RecordedHistorySegment"]],["impl UnwindSafe for ArchivedHistorySegment",1,["subspace_core_primitives::segments::ArchivedHistorySegment"]],["impl UnwindSafe for Randomness",1,["subspace_core_primitives::Randomness"]],["impl UnwindSafe for PosSeed",1,["subspace_core_primitives::PosSeed"]],["impl UnwindSafe for PosProof",1,["subspace_core_primitives::PosProof"]],["impl UnwindSafe for PotKey",1,["subspace_core_primitives::PotKey"]],["impl UnwindSafe for PotSeed",1,["subspace_core_primitives::PotSeed"]],["impl UnwindSafe for PotOutput",1,["subspace_core_primitives::PotOutput"]],["impl UnwindSafe for PotCheckpoints",1,["subspace_core_primitives::PotCheckpoints"]],["impl UnwindSafe for PublicKey",1,["subspace_core_primitives::PublicKey"]],["impl UnwindSafe for RewardSignature",1,["subspace_core_primitives::RewardSignature"]],["impl UnwindSafe for ArchivedBlockProgress",1,["subspace_core_primitives::ArchivedBlockProgress"]],["impl UnwindSafe for LastArchivedBlock",1,["subspace_core_primitives::LastArchivedBlock"]],["impl UnwindSafe for SegmentHeader",1,["subspace_core_primitives::SegmentHeader"]],["impl<PublicKey, RewardAddress> UnwindSafe for Solution<PublicKey, RewardAddress>
where\n PublicKey: UnwindSafe,\n RewardAddress: UnwindSafe,
",1,["subspace_core_primitives::Solution"]],["impl UnwindSafe for U256",1,["subspace_core_primitives::U256"]],["impl UnwindSafe for SectorSlotChallenge",1,["subspace_core_primitives::SectorSlotChallenge"]],["impl UnwindSafe for SectorId",1,["subspace_core_primitives::SectorId"]],["impl<T> UnwindSafe for NonEmptyVec<T>
where\n T: UnwindSafe,
",1,["subspace_core_primitives::NonEmptyVec"]],["impl UnwindSafe for NonEmptyVecErr",1,["subspace_core_primitives::NonEmptyVecErr"]]], "subspace_erasure_coding":[["impl UnwindSafe for ErasureCoding",1,["subspace_erasure_coding::ErasureCoding"]]], -"subspace_farmer":[["impl UnwindSafe for Identity",1,["subspace_farmer::identity::Identity"]],["impl !UnwindSafe for NodeRpcClient",1,["subspace_farmer::node_client::node_rpc_client::NodeRpcClient"]],["impl<NC> !UnwindSafe for CacheWorker<NC>",1,["subspace_farmer::piece_cache::CacheWorker"]],["impl !UnwindSafe for PieceCache",1,["subspace_farmer::piece_cache::PieceCache"]],["impl UnwindSafe for RayonFiles",1,["subspace_farmer::single_disk_farm::farming::rayon_files::RayonFiles"]],["impl UnwindSafe for AuditEvent",1,["subspace_farmer::single_disk_farm::farming::AuditEvent"]],["impl !UnwindSafe for FarmingError",1,["subspace_farmer::single_disk_farm::farming::FarmingError"]],["impl<'a, PosTable> !UnwindSafe for PlotAuditOptions<'a, PosTable>",1,["subspace_farmer::single_disk_farm::farming::PlotAuditOptions"]],["impl<Plot> UnwindSafe for PlotAudit<Plot>
where\n Plot: UnwindSafe,
",1,["subspace_farmer::single_disk_farm::farming::PlotAudit"]],["impl !UnwindSafe for DiskPieceCacheError",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"]],["impl UnwindSafe for Offset",1,["subspace_farmer::single_disk_farm::piece_cache::Offset"]],["impl UnwindSafe for DiskPieceCache",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCache"]],["impl !UnwindSafe for PieceReader",1,["subspace_farmer::single_disk_farm::piece_reader::PieceReader"]],["impl !UnwindSafe for PlottingError",1,["subspace_farmer::single_disk_farm::plotting::PlottingError"]],["impl UnwindSafe for SingleDiskFarmId",1,["subspace_farmer::single_disk_farm::SingleDiskFarmId"]],["impl UnwindSafe for SingleDiskFarmInfoLock",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock"]],["impl UnwindSafe for SingleDiskFarmInfo",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfo"]],["impl !UnwindSafe for SingleDiskFarmSummary",1,["subspace_farmer::single_disk_farm::SingleDiskFarmSummary"]],["impl<NC, PG> !UnwindSafe for SingleDiskFarmOptions<NC, PG>",1,["subspace_farmer::single_disk_farm::SingleDiskFarmOptions"]],["impl !UnwindSafe for SingleDiskFarmError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmError"]],["impl !UnwindSafe for SingleDiskFarmScrubError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"]],["impl !UnwindSafe for BackgroundTaskError",1,["subspace_farmer::single_disk_farm::BackgroundTaskError"]],["impl UnwindSafe for SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::SectorPlottingDetails"]],["impl UnwindSafe for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::SectorExpirationDetails"]],["impl UnwindSafe for SectorUpdate",1,["subspace_farmer::single_disk_farm::SectorUpdate"]],["impl !UnwindSafe for SingleDiskFarm",1,["subspace_farmer::single_disk_farm::SingleDiskFarm"]],["impl !UnwindSafe for PlottingThreadPoolPair",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolPair"]],["impl !UnwindSafe for PlottingThreadPoolsGuard",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolsGuard"]],["impl !UnwindSafe for PlottingThreadPoolManager",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolManager"]],["impl<PV, NC> !UnwindSafe for FarmerPieceGetter<PV, NC>",1,["subspace_farmer::utils::farmer_piece_getter::FarmerPieceGetter"]],["impl<NC> !UnwindSafe for SegmentCommitmentPieceValidator<NC>",1,["subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator"]],["impl !UnwindSafe for ReadersAndPieces",1,["subspace_farmer::utils::readers_and_pieces::ReadersAndPieces"]],["impl UnwindSafe for Ss58ParsingError",1,["subspace_farmer::utils::ss58::Ss58ParsingError"]],["impl<T> UnwindSafe for AsyncJoinOnDrop<T>",1,["subspace_farmer::utils::AsyncJoinOnDrop"]],["impl UnwindSafe for CpuCoreSet",1,["subspace_farmer::utils::CpuCoreSet"]]], -"subspace_farmer_components":[["impl<'a, Sector> UnwindSafe for AuditResult<'a, Sector>
where\n Sector: UnwindSafe,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl UnwindSafe for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl UnwindSafe for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl !UnwindSafe for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> !UnwindSafe for PlotSectorOptions<'a, PosTable, PG>",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl UnwindSafe for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> !UnwindSafe for DownloadSectorOptions<'a, PG>",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> !UnwindSafe for EncodeSectorOptions<'a, PosTable>",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl !UnwindSafe for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> UnwindSafe for SolutionCandidates<'a, Sector>
where\n Sector: UnwindSafe,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl !UnwindSafe for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl UnwindSafe for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl UnwindSafe for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl UnwindSafe for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> !UnwindSafe for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl UnwindSafe for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl UnwindSafe for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl UnwindSafe for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl UnwindSafe for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> UnwindSafe for ReadAt<S, A>
where\n A: UnwindSafe,\n S: UnwindSafe,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> UnwindSafe for AsyncReadBytes<B>
where\n B: UnwindSafe,
",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> UnwindSafe for ReadAtOffset<'a, T>
where\n T: RefUnwindSafe,
",1,["subspace_farmer_components::ReadAtOffset"]],["impl UnwindSafe for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], +"subspace_farmer":[["impl UnwindSafe for Identity",1,["subspace_farmer::identity::Identity"]],["impl !UnwindSafe for NodeRpcClient",1,["subspace_farmer::node_client::node_rpc_client::NodeRpcClient"]],["impl<NC> !UnwindSafe for CacheWorker<NC>",1,["subspace_farmer::piece_cache::CacheWorker"]],["impl !UnwindSafe for PieceCache",1,["subspace_farmer::piece_cache::PieceCache"]],["impl UnwindSafe for RayonFiles",1,["subspace_farmer::single_disk_farm::farming::rayon_files::RayonFiles"]],["impl UnwindSafe for AuditingDetails",1,["subspace_farmer::single_disk_farm::farming::AuditingDetails"]],["impl UnwindSafe for ProvingResult",1,["subspace_farmer::single_disk_farm::farming::ProvingResult"]],["impl UnwindSafe for ProvingDetails",1,["subspace_farmer::single_disk_farm::farming::ProvingDetails"]],["impl !UnwindSafe for FarmingNotification",1,["subspace_farmer::single_disk_farm::farming::FarmingNotification"]],["impl UnwindSafe for DecodedFarmingError",1,["subspace_farmer::single_disk_farm::farming::DecodedFarmingError"]],["impl !UnwindSafe for FarmingError",1,["subspace_farmer::single_disk_farm::farming::FarmingError"]],["impl<'a, PosTable> !UnwindSafe for PlotAuditOptions<'a, PosTable>",1,["subspace_farmer::single_disk_farm::farming::PlotAuditOptions"]],["impl<Plot> UnwindSafe for PlotAudit<Plot>
where\n Plot: UnwindSafe,
",1,["subspace_farmer::single_disk_farm::farming::PlotAudit"]],["impl !UnwindSafe for DiskPieceCacheError",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCacheError"]],["impl UnwindSafe for Offset",1,["subspace_farmer::single_disk_farm::piece_cache::Offset"]],["impl UnwindSafe for DiskPieceCache",1,["subspace_farmer::single_disk_farm::piece_cache::DiskPieceCache"]],["impl !UnwindSafe for PieceReader",1,["subspace_farmer::single_disk_farm::piece_reader::PieceReader"]],["impl UnwindSafe for SectorPlottingDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorPlottingDetails"]],["impl UnwindSafe for SectorExpirationDetails",1,["subspace_farmer::single_disk_farm::plotting::SectorExpirationDetails"]],["impl !UnwindSafe for PlottingError",1,["subspace_farmer::single_disk_farm::plotting::PlottingError"]],["impl UnwindSafe for SingleDiskFarmId",1,["subspace_farmer::single_disk_farm::SingleDiskFarmId"]],["impl UnwindSafe for SingleDiskFarmInfoLock",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfoLock"]],["impl UnwindSafe for SingleDiskFarmInfo",1,["subspace_farmer::single_disk_farm::SingleDiskFarmInfo"]],["impl !UnwindSafe for SingleDiskFarmSummary",1,["subspace_farmer::single_disk_farm::SingleDiskFarmSummary"]],["impl<NC, PG> !UnwindSafe for SingleDiskFarmOptions<NC, PG>",1,["subspace_farmer::single_disk_farm::SingleDiskFarmOptions"]],["impl !UnwindSafe for SingleDiskFarmError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmError"]],["impl !UnwindSafe for SingleDiskFarmScrubError",1,["subspace_farmer::single_disk_farm::SingleDiskFarmScrubError"]],["impl !UnwindSafe for BackgroundTaskError",1,["subspace_farmer::single_disk_farm::BackgroundTaskError"]],["impl UnwindSafe for SectorUpdate",1,["subspace_farmer::single_disk_farm::SectorUpdate"]],["impl !UnwindSafe for SingleDiskFarm",1,["subspace_farmer::single_disk_farm::SingleDiskFarm"]],["impl !UnwindSafe for PlottingThreadPoolPair",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolPair"]],["impl !UnwindSafe for PlottingThreadPoolsGuard",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolsGuard"]],["impl !UnwindSafe for PlottingThreadPoolManager",1,["subspace_farmer::thread_pool_manager::PlottingThreadPoolManager"]],["impl<PV, NC> !UnwindSafe for FarmerPieceGetter<PV, NC>",1,["subspace_farmer::utils::farmer_piece_getter::FarmerPieceGetter"]],["impl<NC> !UnwindSafe for SegmentCommitmentPieceValidator<NC>",1,["subspace_farmer::utils::piece_validator::SegmentCommitmentPieceValidator"]],["impl !UnwindSafe for ReadersAndPieces",1,["subspace_farmer::utils::readers_and_pieces::ReadersAndPieces"]],["impl UnwindSafe for Ss58ParsingError",1,["subspace_farmer::utils::ss58::Ss58ParsingError"]],["impl<T> UnwindSafe for AsyncJoinOnDrop<T>",1,["subspace_farmer::utils::AsyncJoinOnDrop"]],["impl UnwindSafe for CpuCoreSet",1,["subspace_farmer::utils::CpuCoreSet"]]], +"subspace_farmer_components":[["impl !UnwindSafe for AuditingError",1,["subspace_farmer_components::auditing::AuditingError"]],["impl<'a, Sector> UnwindSafe for AuditResult<'a, Sector>
where\n Sector: UnwindSafe,
",1,["subspace_farmer_components::auditing::AuditResult"]],["impl UnwindSafe for PieceGetterRetryPolicy",1,["subspace_farmer_components::plotting::PieceGetterRetryPolicy"]],["impl UnwindSafe for PlottedSector",1,["subspace_farmer_components::plotting::PlottedSector"]],["impl !UnwindSafe for PlottingError",1,["subspace_farmer_components::plotting::PlottingError"]],["impl<'a, PosTable, PG> !UnwindSafe for PlotSectorOptions<'a, PosTable, PG>",1,["subspace_farmer_components::plotting::PlotSectorOptions"]],["impl UnwindSafe for DownloadedSector",1,["subspace_farmer_components::plotting::DownloadedSector"]],["impl<'a, PG> !UnwindSafe for DownloadSectorOptions<'a, PG>",1,["subspace_farmer_components::plotting::DownloadSectorOptions"]],["impl<'a, PosTable> !UnwindSafe for EncodeSectorOptions<'a, PosTable>",1,["subspace_farmer_components::plotting::EncodeSectorOptions"]],["impl !UnwindSafe for ProvingError",1,["subspace_farmer_components::proving::ProvingError"]],["impl<'a, Sector> UnwindSafe for SolutionCandidates<'a, Sector>
where\n Sector: UnwindSafe,
",1,["subspace_farmer_components::proving::SolutionCandidates"]],["impl !UnwindSafe for ReadingError",1,["subspace_farmer_components::reading::ReadingError"]],["impl UnwindSafe for PlotRecord",1,["subspace_farmer_components::reading::PlotRecord"]],["impl UnwindSafe for SectorMetadata",1,["subspace_farmer_components::sector::SectorMetadata"]],["impl UnwindSafe for SectorMetadataChecksummed",1,["subspace_farmer_components::sector::SectorMetadataChecksummed"]],["impl<'a> !UnwindSafe for EncodedChunksUsed<'a>",1,["subspace_farmer_components::sector::EncodedChunksUsed"]],["impl UnwindSafe for SectorContentsMapFromBytesError",1,["subspace_farmer_components::sector::SectorContentsMapFromBytesError"]],["impl UnwindSafe for SectorContentsMapEncodeIntoError",1,["subspace_farmer_components::sector::SectorContentsMapEncodeIntoError"]],["impl UnwindSafe for SectorContentsMapIterationError",1,["subspace_farmer_components::sector::SectorContentsMapIterationError"]],["impl UnwindSafe for SectorContentsMap",1,["subspace_farmer_components::sector::SectorContentsMap"]],["impl<S, A> UnwindSafe for ReadAt<S, A>
where\n A: UnwindSafe,\n S: UnwindSafe,
",1,["subspace_farmer_components::ReadAt"]],["impl<B> UnwindSafe for AsyncReadBytes<B>
where\n B: UnwindSafe,
",1,["subspace_farmer_components::AsyncReadBytes"]],["impl<'a, T> UnwindSafe for ReadAtOffset<'a, T>
where\n T: RefUnwindSafe,
",1,["subspace_farmer_components::ReadAtOffset"]],["impl UnwindSafe for FarmerProtocolInfo",1,["subspace_farmer_components::FarmerProtocolInfo"]]], "subspace_malicious_operator":[["impl<CNetwork> !UnwindSafe for DomainInstanceStarter<CNetwork>",1,["subspace_malicious_operator::malicious_domain_instance_starter::DomainInstanceStarter"]],["impl UnwindSafe for Cli",1,["subspace_malicious_operator::Cli"]],["impl UnwindSafe for DomainCli",1,["subspace_malicious_operator::DomainCli"]]], "subspace_metrics":[["impl !UnwindSafe for RegistryAdapter",1,["subspace_metrics::RegistryAdapter"]],["impl UnwindSafe for metrics",1,["subspace_metrics::metrics"]]], "subspace_networking":[["impl UnwindSafe for PeerAddressRemovedEvent",1,["subspace_networking::behavior::persistent_parameters::PeerAddressRemovedEvent"]],["impl UnwindSafe for KnownPeersManagerConfig",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerConfig"]],["impl !UnwindSafe for KnownPeersManagerPersistenceError",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManagerPersistenceError"]],["impl !UnwindSafe for KnownPeersManager",1,["subspace_networking::behavior::persistent_parameters::KnownPeersManager"]],["impl UnwindSafe for KademliaMode",1,["subspace_networking::constructor::KademliaMode"]],["impl<LocalRecordProvider> !UnwindSafe for Config<LocalRecordProvider>",1,["subspace_networking::constructor::Config"]],["impl !UnwindSafe for CreationError",1,["subspace_networking::constructor::CreationError"]],["impl !UnwindSafe for TopicSubscription",1,["subspace_networking::node::TopicSubscription"]],["impl UnwindSafe for GetClosestPeersError",1,["subspace_networking::node::GetClosestPeersError"]],["impl !UnwindSafe for SubscribeError",1,["subspace_networking::node::SubscribeError"]],["impl !UnwindSafe for SendRequestError",1,["subspace_networking::node::SendRequestError"]],["impl !UnwindSafe for Node",1,["subspace_networking::node::Node"]],["impl<LocalRecordProvider> !UnwindSafe for NodeRunner<LocalRecordProvider>",1,["subspace_networking::node_runner::NodeRunner"]],["impl<Request> !UnwindSafe for GenericRequestHandler<Request>",1,["subspace_networking::protocols::request_response::handlers::generic_request_handler::GenericRequestHandler"]],["impl UnwindSafe for PieceByIndexRequest",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexRequest"]],["impl UnwindSafe for PieceByIndexResponse",1,["subspace_networking::protocols::request_response::handlers::piece_by_index::PieceByIndexResponse"]],["impl UnwindSafe for SegmentHeaderRequest",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderRequest"]],["impl UnwindSafe for SegmentHeaderResponse",1,["subspace_networking::protocols::request_response::handlers::segment_header::SegmentHeaderResponse"]],["impl UnwindSafe for PeerDiscovered",1,["subspace_networking::shared::PeerDiscovered"]],["impl UnwindSafe for MultihashCode",1,["subspace_networking::utils::multihash::MultihashCode"]],["impl UnwindSafe for NoPieceValidator",1,["subspace_networking::utils::piece_provider::NoPieceValidator"]],["impl UnwindSafe for RetryPolicy",1,["subspace_networking::utils::piece_provider::RetryPolicy"]],["impl<PV> !UnwindSafe for PieceProvider<PV>",1,["subspace_networking::utils::piece_provider::PieceProvider"]],["impl<T> UnwindSafe for KeyWrapper<T>
where\n T: UnwindSafe,
",1,["subspace_networking::utils::unique_record_binary_heap::KeyWrapper"]],["impl<K> UnwindSafe for UniqueRecordBinaryHeap<K>
where\n K: RefUnwindSafe,
",1,["subspace_networking::utils::unique_record_binary_heap::UniqueRecordBinaryHeap"]],["impl UnwindSafe for SubspaceMetrics",1,["subspace_networking::utils::SubspaceMetrics"]]], diff --git a/trait.impl/domain_service/providers/trait.BlockImportProvider.js b/trait.impl/domain_service/providers/trait.BlockImportProvider.js index 670ec2fe74..c06b43c034 100644 --- a/trait.impl/domain_service/providers/trait.BlockImportProvider.js +++ b/trait.impl/domain_service/providers/trait.BlockImportProvider.js @@ -1,4 +1,4 @@ (function() {var implementors = { -"domain_eth_service":[["impl<Block, RuntimeApi, CT, EC> BlockImportProvider<Block, Client<Backend<Block>, LocalCallExecutor<Block, Backend<Block>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block, RuntimeApi>> for EthProvider<CT, EC>
where\n Block: BlockT,\n RuntimeApi: ConstructRuntimeApi<Block, FullClient<Block, RuntimeApi>> + Send + Sync + 'static,\n RuntimeApi::RuntimeApi: ApiExt<Block> + Core<Block> + BlockBuilder<Block> + EthereumRuntimeRPCApi<Block>,
"]], +"domain_eth_service":[["impl<Block, RuntimeApi, CT, EC> BlockImportProvider<Block, Client<Backend<Block>, LocalCallExecutor<Block, Backend<Block>, WasmExecutor<((HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions, HostFunctions),)>>, Block, RuntimeApi>> for EthProvider<CT, EC>
where\n Block: BlockT,\n RuntimeApi: ConstructRuntimeApi<Block, FullClient<Block, RuntimeApi>> + Send + Sync + 'static,\n RuntimeApi::RuntimeApi: ApiExt<Block> + Core<Block> + BlockBuilder<Block> + EthereumRuntimeRPCApi<Block>,
"]], "domain_service":[] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/domain_service/providers/trait.RpcProvider.js b/trait.impl/domain_service/providers/trait.RpcProvider.js index ccb2b50c92..d0b83d84c5 100644 --- a/trait.impl/domain_service/providers/trait.RpcProvider.js +++ b/trait.impl/domain_service/providers/trait.RpcProvider.js @@ -1,4 +1,4 @@ (function() {var implementors = { -"domain_eth_service":[["impl<Block, Client, BE, TxPool, CA, AccountId, CT, EC, CIDP> RpcProvider<Block, Client, TxPool, CA, BE, AccountId, CIDP> for EthProvider<CT, EC>
where\n Block: BlockT<Hash = H256>,\n BE: Backend<Block> + 'static,\n Client: ProvideRuntimeApi<Block> + BlockchainEvents<Block> + StorageProvider<Block, BE> + HeaderBackend<Block> + CallApiAt<Block> + HeaderMetadata<Block, Error = Error> + BlockBackend<Block> + AuxStore + Send + Sync + 'static,\n Client::Api: TransactionPaymentRuntimeApi<Block, Balance> + EthereumRuntimeRPCApi<Block> + AccountNonceApi<Block, AccountId, Nonce> + ConvertTransactionRuntimeApi<Block> + BlockBuilder<Block>,\n CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Clone + Default + Send + Sync + 'static,\n EC: EthConfig<Block, Client>,\n TxPool: TransactionPool<Block = Block> + Sync + Send + 'static,\n CA: ChainApi<Block = Block> + 'static,\n AccountId: DeserializeOwned + Encode + Debug + Decode + Display + Clone + Sync + Send + 'static,\n CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
"]], +"domain_eth_service":[["impl<Block, Client, BE, TxPool, CA, AccountId, CT, EC, CIDP> RpcProvider<Block, Client, TxPool, CA, BE, AccountId, CIDP> for EthProvider<CT, EC>
where\n Block: BlockT<Hash = H256>,\n BE: Backend<Block> + 'static,\n Client: ProvideRuntimeApi<Block> + BlockchainEvents<Block> + StorageProvider<Block, BE> + HeaderBackend<Block> + CallApiAt<Block> + HeaderMetadata<Block, Error = Error> + BlockBackend<Block> + AuxStore + Send + Sync + 'static,\n Client::Api: TransactionPaymentRuntimeApi<Block, Balance> + EthereumRuntimeRPCApi<Block> + AccountNonceApi<Block, AccountId, Nonce> + ConvertTransactionRuntimeApi<Block> + BlockBuilder<Block>,\n CT: ConvertTransaction<<Block as BlockT>::Extrinsic> + Clone + Default + Send + Sync + 'static,\n EC: EthConfig<Block, Client>,\n TxPool: TransactionPool<Block = Block> + Sync + Send + 'static,\n CA: ChainApi<Block = Block> + 'static,\n AccountId: DeserializeOwned + Encode + Debug + Decode + Display + Clone + Sync + Send + 'static,\n CIDP: CreateInherentDataProviders<Block, ()> + Send + Clone + 'static,
"]], "domain_service":[] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/parity_scale_codec/codec/trait.Decode.js b/trait.impl/parity_scale_codec/codec/trait.Decode.js index 33c2266607..0e1a9324cf 100644 --- a/trait.impl/parity_scale_codec/codec/trait.Decode.js +++ b/trait.impl/parity_scale_codec/codec/trait.Decode.js @@ -28,7 +28,7 @@ "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 SectorExpirationDetails"],["impl Decode for SectorPlottingDetails"],["impl Decode for SectorUpdate"]], +"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_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 1bf709aeba..1948cb6db9 100644 --- a/trait.impl/parity_scale_codec/codec/trait.Encode.js +++ b/trait.impl/parity_scale_codec/codec/trait.Encode.js @@ -28,7 +28,7 @@ "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 SectorExpirationDetails"],["impl Encode for SectorPlottingDetails"],["impl Encode for SectorUpdate"]], +"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_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 b46efa13dd..e32b324a4d 100644 --- a/trait.impl/parity_scale_codec/encode_like/trait.EncodeLike.js +++ b/trait.impl/parity_scale_codec/encode_like/trait.EncodeLike.js @@ -28,7 +28,7 @@ "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 SectorPlottingDetails"],["impl EncodeLike for SectorExpirationDetails"],["impl EncodeLike for SectorUpdate"]], +"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_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/sc_transaction_pool_api/trait.LocalTransactionPool.js b/trait.impl/sc_transaction_pool_api/trait.LocalTransactionPool.js index 5f628872d4..9132e2b01a 100644 --- a/trait.impl/sc_transaction_pool_api/trait.LocalTransactionPool.js +++ b/trait.impl/sc_transaction_pool_api/trait.LocalTransactionPool.js @@ -1,3 +1,3 @@ (function() {var implementors = { -"subspace_service":[["impl<Block, Client, DomainHeader> LocalTransactionPool for BasicPoolWrapper<Block, FullChainApiWrapper<Client, Block, DomainHeader>>
where\n Block: BlockT,\n <<<Block as BlockT>::Header as HeaderT>::Number as TryInto<u32>>::Error: Debug,\n DomainHeader: HeaderT,\n Client: ProvideRuntimeApi<Block> + AuxStore + BlockBackend<Block> + BlockIdTo<Block> + HeaderBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync + 'static,\n Client::Api: TaggedTransactionQueue<Block> + SubspaceApi<Block, FarmerPublicKey> + FraudProofApi<Block, DomainHeader> + DomainsApi<Block, DomainHeader>,
"]] +"subspace_service":[["impl<Block, Client, DomainHeader> LocalTransactionPool for BasicPoolWrapper<Block, FullChainApiWrapper<Client, Block, DomainHeader>>
where\n Block: BlockT,\n <<<Block as BlockT>::Header as HeaderT>::Number as TryInto<u32>>::Error: Debug,\n DomainHeader: HeaderT,\n Client: ProvideRuntimeApi<Block> + AuxStore + BlockBackend<Block> + BlockIdTo<Block> + HeaderBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync + 'static,\n Client::Api: TaggedTransactionQueue<Block> + SubspaceApi<Block, FarmerPublicKey> + FraudProofApi<Block, DomainHeader> + DomainsApi<Block, DomainHeader>,
"]] };if (window.register_implementors) {window.register_implementors(implementors);} else {window.pending_implementors = implementors;}})() \ No newline at end of file diff --git a/trait.impl/scale_info/trait.TypeInfo.js b/trait.impl/scale_info/trait.TypeInfo.js index 6c14125535..dbca8feca1 100644 --- a/trait.impl/scale_info/trait.TypeInfo.js +++ b/trait.impl/scale_info/trait.TypeInfo.js @@ -6,7 +6,7 @@ "orml_vesting":[["impl<BlockNumber, Balance> TypeInfo for VestingSchedule<BlockNumber, Balance>
where\n BlockNumber: TypeInfo + 'static,\n Balance: HasCompact + MaxEncodedLen + HasCompact + TypeInfo + 'static,
"],["impl<T> TypeInfo for Event<T>
where\n T::AccountId: TypeInfo + 'static,\n VestingSchedule<BlockNumberFor<T>, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static,\n <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n PhantomData<T>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n <T::Lookup as StaticLookup>::Source: TypeInfo + 'static,\n VestingSchedule<BlockNumberFor<T>, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static,\n Vec<VestingSchedule<BlockNumberFor<T>, <<T as Config>::Currency as Currency<<T as Config>::AccountId>>::Balance>>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"]], "pallet_block_fees":[["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n T::Balance: HasCompact,\n T: Config + 'static,
"]], "pallet_domain_id":[["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n T: Config + 'static,
"]], -"pallet_domains":[["impl<AccountId> TypeInfo for DomainConfig<AccountId>
where\n OperatorAllowList<AccountId>: TypeInfo + 'static,\n AccountId: Ord + TypeInfo + 'static,
"],["impl TypeInfo for Error"],["impl<T> TypeInfo for Event<T>
where\n BlockNumberFor<T>: TypeInfo + 'static,\n <T as Config>::AccountId: TypeInfo + 'static,\n <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n Option<DomainBlockNumberFor<T>>: TypeInfo + 'static,\n SlashedReason<DomainBlockNumberFor<T>, ReceiptHashFor<T>>: TypeInfo + 'static,\n PhantomData<T>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl TypeInfo for BundleError"],["impl<Hash> TypeInfo for ScheduledRuntimeUpgrade<Hash>
where\n Hash: TypeInfo + 'static,
"],["impl TypeInfo for TxRangeState"],["impl TypeInfo for FraudProofError"],["impl TypeInfo for DomainRuntimeInfo"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for BlockTreeNode<Number, Hash, DomainNumber, DomainHash, Balance>
where\n ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainNumber: TypeInfo + 'static,\n DomainHash: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n OpaqueBundleOf<T>: TypeInfo + 'static,\n Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>: TypeInfo + 'static,\n <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n OperatorConfig<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static,\n DomainConfig<T::AccountId>: TypeInfo + 'static,\n T::Share: TypeInfo + 'static,\n OperatorAllowList<T::AccountId>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl TypeInfo for Error"],["impl TypeInfo for Error"],["impl<Number, ReceiptHash, AccountId> TypeInfo for DomainObject<Number, ReceiptHash, AccountId>
where\n AccountId: TypeInfo + 'static + Ord,\n Number: TypeInfo + 'static,\n ReceiptHash: TypeInfo + 'static,\n DomainConfig<AccountId>: TypeInfo + 'static,
"],["impl<Balance> TypeInfo for OperatorConfig<Balance>
where\n Balance: TypeInfo + 'static,
"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl<Number, Hash> TypeInfo for RuntimeObject<Number, Hash>
where\n Hash: TypeInfo + 'static,\n Number: TypeInfo + 'static,
"],["impl<DomainBlock, ReceiptHash> TypeInfo for SlashedReason<DomainBlock, ReceiptHash>
where\n DomainBlock: TypeInfo + 'static,\n ReceiptHash: TypeInfo + 'static,
"]], +"pallet_domains":[["impl<AccountId> TypeInfo for DomainConfig<AccountId>
where\n OperatorAllowList<AccountId>: TypeInfo + 'static,\n AccountId: Ord + TypeInfo + 'static,
"],["impl TypeInfo for Error"],["impl<T> TypeInfo for Event<T>
where\n BlockNumberFor<T>: TypeInfo + 'static,\n <T as Config>::AccountId: TypeInfo + 'static,\n <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n Option<DomainBlockNumberFor<T>>: TypeInfo + 'static,\n SlashedReason<DomainBlockNumberFor<T>, ReceiptHashFor<T>>: TypeInfo + 'static,\n PhantomData<T>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl TypeInfo for BundleError"],["impl<Hash> TypeInfo for ScheduledRuntimeUpgrade<Hash>
where\n Hash: TypeInfo + 'static,
"],["impl TypeInfo for TxRangeState"],["impl TypeInfo for FraudProofError"],["impl TypeInfo for DomainRuntimeInfo"],["impl<Number, Hash, DomainNumber, DomainHash, Balance> TypeInfo for BlockTreeNode<Number, Hash, DomainNumber, DomainHash, Balance>
where\n ExecutionReceipt<Number, Hash, DomainNumber, DomainHash, Balance>: TypeInfo + 'static,\n Number: TypeInfo + 'static,\n Hash: TypeInfo + 'static,\n DomainNumber: TypeInfo + 'static,\n DomainHash: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n OpaqueBundleOf<T>: TypeInfo + 'static,\n Box<FraudProof<BlockNumberFor<T>, T::Hash, T::DomainHeader>>: TypeInfo + 'static,\n <<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance: TypeInfo + 'static,\n OperatorConfig<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static,\n DomainConfig<T::AccountId>: TypeInfo + 'static,\n T::Share: TypeInfo + 'static,\n OperatorAllowList<T::AccountId>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl TypeInfo for Error"],["impl TypeInfo for Error"],["impl<Number, ReceiptHash, AccountId> TypeInfo for DomainObject<Number, ReceiptHash, AccountId>
where\n AccountId: TypeInfo + 'static + Ord,\n Number: TypeInfo + 'static,\n ReceiptHash: TypeInfo + 'static,\n DomainConfig<AccountId>: TypeInfo + 'static,
"],["impl<Balance> TypeInfo for OperatorConfig<Balance>
where\n Balance: TypeInfo + 'static,
"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl<Number, Hash> TypeInfo for RuntimeObject<Number, Hash>
where\n Hash: TypeInfo + 'static,\n Number: TypeInfo + 'static,
"],["impl<DomainBlock, ReceiptHash> TypeInfo for SlashedReason<DomainBlock, ReceiptHash>
where\n DomainBlock: TypeInfo + 'static,\n ReceiptHash: TypeInfo + 'static,
"]], "pallet_feeds":[["impl<T> TypeInfo for Event<T>
where\n T::FeedId: TypeInfo + 'static,\n T::AccountId: TypeInfo + 'static,\n PhantomData<T>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl TypeInfo for TotalObjectsAndSize"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n T::FeedProcessorKind: TypeInfo + 'static,\n T::FeedId: TypeInfo + 'static,\n <T::Lookup as StaticLookup>::Source: TypeInfo + 'static,\n T: Config + 'static,
"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl<FeedProcessorId, AccountId> TypeInfo for FeedConfig<FeedProcessorId, AccountId>
where\n FeedProcessorId: TypeInfo + 'static,\n AccountId: TypeInfo + 'static,
"]], "pallet_grandpa_finality_verifier":[["impl TypeInfo for InitializationData"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n T: Config + 'static,
"]], "pallet_messenger":[["impl<T> TypeInfo for Event<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl<T> TypeInfo for Error<T>
where\n PhantomData<T>: TypeInfo + 'static,\n T: 'static,
"],["impl<T> TypeInfo for Call<T>
where\n PhantomData<(T,)>: TypeInfo + 'static,\n InitiateChannelParams<<<T as Config>::Currency as Inspect<<T as Config>::AccountId>>::Balance>: TypeInfo + 'static,\n CrossDomainMessage<BlockNumberFor<T>, T::Hash, <<T as Config>::Hashing as Hash>::Output>: TypeInfo + 'static,\n T: Config + 'static,
"],["impl<Balance> TypeInfo for Channel<Balance>
where\n FeeModel<Balance>: TypeInfo + 'static,\n Balance: TypeInfo + 'static,
"],["impl TypeInfo for ChannelState"],["impl TypeInfo for OutboxMessageResult"]], diff --git a/type.impl/domain_client_operator/operator/struct.Operator.js b/type.impl/domain_client_operator/operator/struct.Operator.js index 2d98e98a67..e7f95610c8 100644 --- a/type.impl/domain_client_operator/operator/struct.Operator.js +++ b/type.impl/domain_client_operator/operator/struct.Operator.js @@ -1,3 +1,3 @@ (function() {var type_impls = { -"domain_service":[["
§

impl<Block, CBlock, Client, CClient, TransactionPool, Backend, E> Operator<Block, CBlock, Client, CClient, TransactionPool, Backend, E>
where\n Block: Block,\n <Block as Block>::Hash: Into<H256>,\n CBlock: Block,\n <<CBlock as Block>::Header as Header>::Number: From<<<Block as Block>::Header as Header>::Number> + Into<<<Block as Block>::Header as Header>::Number>,\n <CBlock as Block>::Hash: From<<Block as Block>::Hash>,\n Client: HeaderBackend<Block> + BlockBackend<Block> + AuxStore + ProvideRuntimeApi<Block> + ProofProvider<Block> + Finalizer<Block, Backend> + 'static,\n <Client as ProvideRuntimeApi<Block>>::Api: DomainCoreApi<Block> + MessengerApi<Block, <<Block as Block>::Header as Header>::Number> + BlockBuilder<Block> + ApiExt<Block> + TaggedTransactionQueue<Block>,\n CClient: HeaderBackend<CBlock> + HeaderMetadata<CBlock, Error = Error> + BlockBackend<CBlock> + ProvideRuntimeApi<CBlock> + ProofProvider<CBlock> + BlockchainEvents<CBlock> + Send + Sync + 'static,\n <CClient as ProvideRuntimeApi<CBlock>>::Api: DomainsApi<CBlock, <Block as Block>::Header> + MessengerApi<CBlock, <<CBlock as Block>::Header as Header>::Number> + BundleProducerElectionApi<CBlock, u128> + FraudProofApi<CBlock, <Block as Block>::Header>,\n Backend: Backend<Block> + Send + Sync + 'static,\n TransactionPool: TransactionPool<Block = Block> + 'static,\n E: CodeExecutor,

pub async fn new<IBNS, CIBNS, NSNS, ASS>(\n spawn_essential: Box<dyn SpawnEssentialNamed>,\n params: OperatorParams<Block, CBlock, Client, CClient, TransactionPool, Backend, E, IBNS, CIBNS, NSNS, ASS>\n) -> Result<Operator<Block, CBlock, Client, CClient, TransactionPool, Backend, E>, Error>
where\n IBNS: Stream<Item = (<<CBlock as Block>::Header as Header>::Number, Sender<()>)> + Send + 'static,\n CIBNS: Stream<Item = BlockImportNotification<CBlock>> + Send + 'static,\n NSNS: Stream<Item = (Slot, Randomness)> + Send + 'static,\n ASS: Stream<Item = Sender<()>> + Send + 'static,

Create a new instance.

\n

pub fn fraud_proof_generator(\n &self\n) -> FraudProofGenerator<Block, CBlock, Client, CClient, Backend, E>

pub fn import_notification_stream(\n &self\n) -> TracingUnboundedReceiver<DomainBlockImportNotification<Block, CBlock>>

Get system domain block import notification stream.

\n

NOTE: Unlike BlockchainEvents::import_notification_stream(), this notification won’t be\nfired until the system domain block’s receipt processing is done.

\n
",0,"domain_service::domain::DomainOperator"],["
§

impl<Block, CBlock, Client, CClient, TransactionPool, Backend, E> Clone for Operator<Block, CBlock, Client, CClient, TransactionPool, Backend, E>
where\n Block: Block,\n CBlock: Block,

§

fn clone(\n &self\n) -> Operator<Block, CBlock, Client, CClient, TransactionPool, Backend, E>

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_service::domain::DomainOperator"]] +"domain_service":[["
source§

impl<Block, CBlock, Client, CClient, TransactionPool, Backend, E> Operator<Block, CBlock, Client, CClient, TransactionPool, Backend, E>
where\n Block: Block,\n <Block as Block>::Hash: Into<H256>,\n CBlock: Block,\n <<CBlock as Block>::Header as Header>::Number: From<<<Block as Block>::Header as Header>::Number> + Into<<<Block as Block>::Header as Header>::Number>,\n <CBlock as Block>::Hash: From<<Block as Block>::Hash>,\n Client: HeaderBackend<Block> + BlockBackend<Block> + AuxStore + ProvideRuntimeApi<Block> + ProofProvider<Block> + Finalizer<Block, Backend> + 'static,\n <Client as ProvideRuntimeApi<Block>>::Api: DomainCoreApi<Block> + MessengerApi<Block, <<Block as Block>::Header as Header>::Number> + BlockBuilder<Block> + ApiExt<Block> + TaggedTransactionQueue<Block>,\n CClient: HeaderBackend<CBlock> + HeaderMetadata<CBlock, Error = Error> + BlockBackend<CBlock> + ProvideRuntimeApi<CBlock> + ProofProvider<CBlock> + BlockchainEvents<CBlock> + Send + Sync + 'static,\n <CClient as ProvideRuntimeApi<CBlock>>::Api: DomainsApi<CBlock, <Block as Block>::Header> + MessengerApi<CBlock, <<CBlock as Block>::Header as Header>::Number> + BundleProducerElectionApi<CBlock, u128> + FraudProofApi<CBlock, <Block as Block>::Header>,\n Backend: Backend<Block> + Send + Sync + 'static,\n TransactionPool: TransactionPool<Block = Block> + 'static,\n E: CodeExecutor,

source

pub async fn new<IBNS, CIBNS, NSNS, ASS>(\n spawn_essential: Box<dyn SpawnEssentialNamed>,\n params: OperatorParams<Block, CBlock, Client, CClient, TransactionPool, Backend, E, IBNS, CIBNS, NSNS, ASS>\n) -> Result<Operator<Block, CBlock, Client, CClient, TransactionPool, Backend, E>, Error>
where\n IBNS: Stream<Item = (<<CBlock as Block>::Header as Header>::Number, Sender<()>)> + Send + 'static,\n CIBNS: Stream<Item = BlockImportNotification<CBlock>> + Send + 'static,\n NSNS: Stream<Item = (Slot, Randomness)> + Send + 'static,\n ASS: Stream<Item = Sender<()>> + Send + 'static,

Create a new instance.

\n
source

pub fn fraud_proof_generator(\n &self\n) -> FraudProofGenerator<Block, CBlock, Client, CClient, Backend, E>

source

pub fn import_notification_stream(\n &self\n) -> TracingUnboundedReceiver<DomainBlockImportNotification<Block, CBlock>>

Get system domain block import notification stream.

\n

NOTE: Unlike BlockchainEvents::import_notification_stream(), this notification won’t be\nfired until the system domain block’s receipt processing is done.

\n
",0,"domain_service::domain::DomainOperator"],["
source§

impl<Block, CBlock, Client, CClient, TransactionPool, Backend, E> Clone for Operator<Block, CBlock, Client, CClient, TransactionPool, Backend, E>
where\n Block: Block,\n CBlock: Block,

source§

fn clone(\n &self\n) -> Operator<Block, CBlock, Client, CClient, TransactionPool, Backend, E>

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_service::domain::DomainOperator"]] };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})() \ No newline at end of file diff --git a/type.impl/pallet_domains/struct.Pallet.js b/type.impl/pallet_domains/struct.Pallet.js index 1f1db58caa..d6f4d577ea 100644 --- a/type.impl/pallet_domains/struct.Pallet.js +++ b/type.impl/pallet_domains/struct.Pallet.js @@ -1,3 +1,3 @@ (function() {var type_impls = { -"pallet_domains":[["
source§

impl<T: Config> Pallet<T>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

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

\n
source

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

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

\n
source

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

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

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

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

Force staking epoch transition for a given domain

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

impl<T: Config> Pallet<T>

source

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

An auto-generated getter for OperatorSigningKey.

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

impl<T: Config> Pallet<T>

source

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

An auto-generated getter for DomainStakingSummary.

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

impl<T: Config> Pallet<T>

source

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

An auto-generated getter for ConsensusBlockHash.

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

impl<T: Config> Pallet<T>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn domain_tx_range(domain_id: DomainId) -> U256

Returns the tx range for the domain.

\n
source

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

source

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

source

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

Returns the best execution chain number.

\n
source

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

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

\n
source

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

Returns the domain block limit of the given domain.

\n
source

pub fn non_empty_er_exists(domain_id: DomainId) -> bool

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

\n
source

pub fn extrinsics_shuffling_seed() -> T::Hash

source

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

source

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

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

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

source

pub fn submit_bundle_unsigned(opaque_bundle: OpaqueBundleOf<T>)

Submits an unsigned extrinsic Call::submit_bundle.

\n
source

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

Submits an unsigned extrinsic Call::submit_fraud_proof.

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

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

source§

fn storage_info() -> Vec<StorageInfo>

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

impl<T> Eq for Pallet<T>

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

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

source§

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

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

fn on_finalize(_: BlockNumberFor<T>)

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

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

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

fn on_runtime_upgrade() -> Weight

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

fn offchain_worker(_n: BlockNumber)

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

fn integrity_test()

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

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

source§

fn index() -> usize

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

fn name() -> &'static str

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

fn name_hash() -> [u8; 16]

Two128 hash of name.
source§

fn module_name() -> &'static str

Name of the Rust module containing the pallet.
source§

fn crate_version() -> CrateVersion

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

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

source§

fn on_finalize(n: BlockNumberFor<T>)

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

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

source§

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

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

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

source§

fn on_runtime_upgrade() -> Weight

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

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

§

type RuntimeCall = Call<T>

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

impl<T> Debug for Pallet<T>

source§

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

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

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

source§

fn integrity_test()

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

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

§

type Call = Call<T>

The call to validate
source§

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

Validate the call right before dispatch. Read more
source§

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

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

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

source§

fn offchain_worker(n: BlockNumberFor<T>)

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

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

source§

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

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

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Self

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

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

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

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

source§

fn before_all_runtime_migrations() -> Weight

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

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

source§

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

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

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

§

type CurrentStorageVersion = StorageVersion

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

fn current_storage_version() -> Self::CurrentStorageVersion

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

fn on_chain_storage_version() -> StorageVersion

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

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

source§

fn on_genesis()

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

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

source§

fn count() -> usize

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

fn infos() -> Vec<PalletInfoData>

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

impl<T> PartialEq for Pallet<T>

source§

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

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

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

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

impl<T: Config> Pallet<T>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

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

\n
source

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

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

\n
source

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

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

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

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

Force staking epoch transition for a given domain

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

impl<T: Config> Pallet<T>

source

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

An auto-generated getter for OperatorSigningKey.

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

impl<T: Config> Pallet<T>

source

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

An auto-generated getter for DomainStakingSummary.

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

impl<T: Config> Pallet<T>

source

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

An auto-generated getter for ConsensusBlockHash.

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

impl<T: Config> Pallet<T>

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

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

source

pub fn domain_tx_range(domain_id: DomainId) -> U256

Returns the tx range for the domain.

\n
source

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

source

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

source

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

Returns the best execution chain number.

\n
source

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

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

\n
source

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

Returns the domain block limit of the given domain.

\n
source

pub fn non_empty_er_exists(domain_id: DomainId) -> bool

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

\n
source

pub fn extrinsics_shuffling_seed() -> T::Hash

source

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

source

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

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

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

source

pub fn submit_bundle_unsigned(opaque_bundle: OpaqueBundleOf<T>)

Submits an unsigned extrinsic Call::submit_bundle.

\n
source

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

Submits an unsigned extrinsic Call::submit_fraud_proof.

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

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

source§

fn storage_info() -> Vec<StorageInfo>

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

impl<T> Eq for Pallet<T>

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

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

source§

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

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

fn on_finalize(_: BlockNumberFor<T>)

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

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

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

fn on_runtime_upgrade() -> Weight

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

fn offchain_worker(_n: BlockNumber)

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

fn integrity_test()

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

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

source§

fn index() -> usize

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

fn name() -> &'static str

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

fn name_hash() -> [u8; 16]

Two128 hash of name.
source§

fn module_name() -> &'static str

Name of the Rust module containing the pallet.
source§

fn crate_version() -> CrateVersion

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

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

source§

fn on_finalize(n: BlockNumberFor<T>)

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

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

source§

fn whitelisted_storage_keys() -> Vec<TrackedStorageKey>

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

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

source§

fn on_runtime_upgrade() -> Weight

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

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

§

type RuntimeCall = Call<T>

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

impl<T> Debug for Pallet<T>

source§

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

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

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

source§

fn integrity_test()

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

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

§

type Call = Call<T>

The call to validate
source§

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

Validate the call right before dispatch. Read more
source§

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

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

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

source§

fn offchain_worker(n: BlockNumberFor<T>)

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

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

source§

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

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

impl<T> Clone for Pallet<T>

source§

fn clone(&self) -> Self

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

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

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

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

source§

fn before_all_runtime_migrations() -> Weight

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

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

source§

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

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

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

§

type CurrentStorageVersion = StorageVersion

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

fn current_storage_version() -> Self::CurrentStorageVersion

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

fn on_chain_storage_version() -> StorageVersion

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

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

source§

fn on_genesis()

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

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

source§

fn count() -> usize

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

fn infos() -> Vec<PalletInfoData>

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

impl<T> PartialEq for Pallet<T>

source§

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

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

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

This method tests for !=. The default implementation is almost always\nsufficient, and should not be overridden without very good reason.
","PartialEq","pallet_domains::pallet::Module"]] };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})() \ No newline at end of file diff --git a/type.impl/subspace_service/transaction_pool/struct.BasicPoolWrapper.js b/type.impl/subspace_service/transaction_pool/struct.BasicPoolWrapper.js index 06ab0e2c2d..7e9d3544d2 100644 --- a/type.impl/subspace_service/transaction_pool/struct.BasicPoolWrapper.js +++ b/type.impl/subspace_service/transaction_pool/struct.BasicPoolWrapper.js @@ -1,3 +1,3 @@ (function() {var type_impls = { -"subspace_service":[["
source§

impl<Block, PoolApi> BasicPoolWrapper<Block, PoolApi>
where\n Block: BlockT,\n PoolApi: ChainApi<Block = Block> + 'static,

source

pub fn pool(&self) -> &Arc<Pool<PoolApi>>

Gets shared reference to the underlying pool.

\n
source

pub fn api(&self) -> &PoolApi

",0,"subspace_service::transaction_pool::FullPool"],["
source§

impl<Block, PoolApi> MaintainedTransactionPool for BasicPoolWrapper<Block, PoolApi>
where\n Block: BlockT,\n PoolApi: ChainApi<Block = Block> + 'static,

source§

fn maintain<'life0, 'async_trait>(\n &'life0 self,\n event: ChainEvent<Self::Block>\n) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where\n Self: 'async_trait,\n 'life0: 'async_trait,

Perform maintenance
","MaintainedTransactionPool","subspace_service::transaction_pool::FullPool"],["
source§

impl<Block, Client, DomainHeader> LocalTransactionPool for BasicPoolWrapper<Block, FullChainApiWrapper<Client, Block, DomainHeader>>
where\n Block: BlockT,\n <<<Block as BlockT>::Header as HeaderT>::Number as TryInto<u32>>::Error: Debug,\n DomainHeader: HeaderT,\n Client: ProvideRuntimeApi<Block> + AuxStore + BlockBackend<Block> + BlockIdTo<Block> + HeaderBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync + 'static,\n Client::Api: TaggedTransactionQueue<Block> + SubspaceApi<Block, FarmerPublicKey> + FraudProofApi<Block, DomainHeader> + DomainsApi<Block, DomainHeader>,

§

type Block = Block

Block type.
§

type Hash = <<FullChainApiWrapper<Client, Block, DomainHeader> as ChainApi>::Block as Block>::Hash

Transaction hash type.
§

type Error = <FullChainApiWrapper<Client, Block, DomainHeader> as ChainApi>::Error

Error type.
source§

fn submit_local(\n &self,\n at: Block::Hash,\n xt: LocalTransactionFor<Self>\n) -> Result<Self::Hash, Self::Error>

Submits the given local unverified transaction to the pool blocking the\ncurrent thread for any necessary pre-verification.\nNOTE: It MUST NOT be used for transactions that originate from the\nnetwork or RPC, since the validation is performed with\nTransactionSource::Local.
","LocalTransactionPool","subspace_service::transaction_pool::FullPool"],["
source§

impl<Block, PoolApi> TransactionPool for BasicPoolWrapper<Block, PoolApi>
where\n Block: BlockT,\n PoolApi: ChainApi<Block = Block> + 'static,

§

type Block = Block

Block type.
§

type Hash = <<PoolApi as ChainApi>::Block as Block>::Hash

Transaction hash type.
§

type InPoolTransaction = Transaction<<BasicPoolWrapper<Block, PoolApi> as TransactionPool>::Hash, <<BasicPoolWrapper<Block, PoolApi> as TransactionPool>::Block as Block>::Extrinsic>

In-pool transaction type.
§

type Error = <PoolApi as ChainApi>::Error

Error type.
source§

fn submit_at(\n &self,\n at: Block::Hash,\n source: TransactionSource,\n xts: Vec<TransactionFor<Self>>\n) -> PoolFuture<Vec<Result<TxHash<Self>, Self::Error>>, Self::Error>

Returns a future that imports a bunch of unverified transactions to the pool.
source§

fn submit_one(\n &self,\n at: Block::Hash,\n source: TransactionSource,\n xt: TransactionFor<Self>\n) -> PoolFuture<TxHash<Self>, Self::Error>

Returns a future that imports one unverified transaction to the pool.
source§

fn submit_and_watch(\n &self,\n at: Block::Hash,\n source: TransactionSource,\n xt: TransactionFor<Self>\n) -> PoolFuture<Pin<Box<TransactionStatusStreamFor<Self>>>, Self::Error>

Returns a future that import a single transaction and starts to watch their progress in the\npool.
source§

fn ready_at(\n &self,\n at: NumberFor<Self::Block>\n) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Transaction<<<PoolApi as ChainApi>::Block as BlockT>::Hash, <<PoolApi as ChainApi>::Block as BlockT>::Extrinsic>>> + Send>> + Send>>

Get an iterator for ready transactions ordered by priority. Read more
source§

fn ready(\n &self\n) -> Box<dyn ReadyTransactions<Item = Arc<Transaction<<<PoolApi as ChainApi>::Block as BlockT>::Hash, <<PoolApi as ChainApi>::Block as BlockT>::Extrinsic>>> + Send>

Get an iterator for ready transactions ordered by priority.
source§

fn remove_invalid(\n &self,\n hashes: &[TxHash<Self>]\n) -> Vec<Arc<Self::InPoolTransaction>>

Remove transactions identified by given hashes (and dependent transactions) from the pool.
source§

fn status(&self) -> PoolStatus

Returns pool status.
source§

fn futures(&self) -> Vec<Self::InPoolTransaction>

Get futures transaction list.
source§

fn import_notification_stream(&self) -> ImportNotificationStream<TxHash<Self>>

Return an event stream of transactions imported to the pool.
source§

fn on_broadcasted(&self, propagations: HashMap<TxHash<Self>, Vec<String>>)

Notify the pool about transactions broadcast.
source§

fn hash_of(&self, xt: &TransactionFor<Self>) -> TxHash<Self>

Returns transaction hash
source§

fn ready_transaction(\n &self,\n hash: &TxHash<Self>\n) -> Option<Arc<Self::InPoolTransaction>>

Return specific ready transaction by hash, if there is one.
","TransactionPool","subspace_service::transaction_pool::FullPool"]] +"subspace_service":[["
source§

impl<Block, PoolApi> BasicPoolWrapper<Block, PoolApi>
where\n Block: BlockT,\n PoolApi: ChainApi<Block = Block> + 'static,

source

pub fn pool(&self) -> &Arc<Pool<PoolApi>>

Gets shared reference to the underlying pool.

\n
source

pub fn api(&self) -> &PoolApi

",0,"subspace_service::transaction_pool::FullPool"],["
source§

impl<Block, PoolApi> MaintainedTransactionPool for BasicPoolWrapper<Block, PoolApi>
where\n Block: BlockT,\n PoolApi: ChainApi<Block = Block> + 'static,

source§

fn maintain<'life0, 'async_trait>(\n &'life0 self,\n event: ChainEvent<Self::Block>\n) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where\n Self: 'async_trait,\n 'life0: 'async_trait,

Perform maintenance
","MaintainedTransactionPool","subspace_service::transaction_pool::FullPool"],["
source§

impl<Block, Client, DomainHeader> LocalTransactionPool for BasicPoolWrapper<Block, FullChainApiWrapper<Client, Block, DomainHeader>>
where\n Block: BlockT,\n <<<Block as BlockT>::Header as HeaderT>::Number as TryInto<u32>>::Error: Debug,\n DomainHeader: HeaderT,\n Client: ProvideRuntimeApi<Block> + AuxStore + BlockBackend<Block> + BlockIdTo<Block> + HeaderBackend<Block> + HeaderMetadata<Block, Error = Error> + Send + Sync + 'static,\n Client::Api: TaggedTransactionQueue<Block> + SubspaceApi<Block, FarmerPublicKey> + FraudProofApi<Block, DomainHeader> + DomainsApi<Block, DomainHeader>,

§

type Block = Block

Block type.
§

type Hash = <<FullChainApiWrapper<Client, Block, DomainHeader> as ChainApi>::Block as Block>::Hash

Transaction hash type.
§

type Error = <FullChainApiWrapper<Client, Block, DomainHeader> as ChainApi>::Error

Error type.
source§

fn submit_local(\n &self,\n at: Block::Hash,\n xt: LocalTransactionFor<Self>\n) -> Result<Self::Hash, Self::Error>

Submits the given local unverified transaction to the pool blocking the\ncurrent thread for any necessary pre-verification.\nNOTE: It MUST NOT be used for transactions that originate from the\nnetwork or RPC, since the validation is performed with\nTransactionSource::Local.
","LocalTransactionPool","subspace_service::transaction_pool::FullPool"],["
source§

impl<Block, PoolApi> TransactionPool for BasicPoolWrapper<Block, PoolApi>
where\n Block: BlockT,\n PoolApi: ChainApi<Block = Block> + 'static,

§

type Block = Block

Block type.
§

type Hash = <<PoolApi as ChainApi>::Block as Block>::Hash

Transaction hash type.
§

type InPoolTransaction = Transaction<<BasicPoolWrapper<Block, PoolApi> as TransactionPool>::Hash, <<BasicPoolWrapper<Block, PoolApi> as TransactionPool>::Block as Block>::Extrinsic>

In-pool transaction type.
§

type Error = <PoolApi as ChainApi>::Error

Error type.
source§

fn submit_at(\n &self,\n at: Block::Hash,\n source: TransactionSource,\n xts: Vec<TransactionFor<Self>>\n) -> PoolFuture<Vec<Result<TxHash<Self>, Self::Error>>, Self::Error>

Returns a future that imports a bunch of unverified transactions to the pool.
source§

fn submit_one(\n &self,\n at: Block::Hash,\n source: TransactionSource,\n xt: TransactionFor<Self>\n) -> PoolFuture<TxHash<Self>, Self::Error>

Returns a future that imports one unverified transaction to the pool.
source§

fn submit_and_watch(\n &self,\n at: Block::Hash,\n source: TransactionSource,\n xt: TransactionFor<Self>\n) -> PoolFuture<Pin<Box<TransactionStatusStreamFor<Self>>>, Self::Error>

Returns a future that import a single transaction and starts to watch their progress in the\npool.
source§

fn ready_at(\n &self,\n at: NumberFor<Self::Block>\n) -> Pin<Box<dyn Future<Output = Box<dyn ReadyTransactions<Item = Arc<Transaction<<<PoolApi as ChainApi>::Block as BlockT>::Hash, <<PoolApi as ChainApi>::Block as BlockT>::Extrinsic>>> + Send>> + Send>>

Get an iterator for ready transactions ordered by priority. Read more
source§

fn ready(\n &self\n) -> Box<dyn ReadyTransactions<Item = Arc<Transaction<<<PoolApi as ChainApi>::Block as BlockT>::Hash, <<PoolApi as ChainApi>::Block as BlockT>::Extrinsic>>> + Send>

Get an iterator for ready transactions ordered by priority.
source§

fn remove_invalid(\n &self,\n hashes: &[TxHash<Self>]\n) -> Vec<Arc<Self::InPoolTransaction>>

Remove transactions identified by given hashes (and dependent transactions) from the pool.
source§

fn status(&self) -> PoolStatus

Returns pool status.
source§

fn futures(&self) -> Vec<Self::InPoolTransaction>

Get futures transaction list.
source§

fn import_notification_stream(&self) -> ImportNotificationStream<TxHash<Self>>

Return an event stream of transactions imported to the pool.
source§

fn on_broadcasted(&self, propagations: HashMap<TxHash<Self>, Vec<String>>)

Notify the pool about transactions broadcast.
source§

fn hash_of(&self, xt: &TransactionFor<Self>) -> TxHash<Self>

Returns transaction hash
source§

fn ready_transaction(\n &self,\n hash: &TxHash<Self>\n) -> Option<Arc<Self::InPoolTransaction>>

Return specific ready transaction by hash, if there is one.
","TransactionPool","subspace_service::transaction_pool::FullPool"]] };if (window.register_type_impls) {window.register_type_impls(type_impls);} else {window.pending_type_impls = type_impls;}})() \ No newline at end of file