Skip to main content

AuraEffectSystem

aura_agent

Struct AuraEffectSystem 

Source 
pub struct AuraEffectSystem { /* private fields */ }
Expand description

Concrete effect system combining all effects for runtime usage

Note: This wraps aura-composition infrastructure for Layer 6 runtime concerns.

§Subsystem Organization

Related fields are grouped into subsystems for better organization:

  • crypto: Cryptographic operations, RNG, secure key storage
  • transport: Network transport, inbox management, statistics
  • journal: Indexed journal, fact registry, publication channel

Remaining fields are core infrastructure used across subsystems.

Implementations§

Source§

impl AuraEffectSystem

Source

pub fn is_testing(&self) -> bool

Check if the effect system is in test mode (bypasses authorization guards)

Source

pub fn is_test_mode(&self) -> bool

Check if the effect system is in explicit test mode (not simulation).

Source

pub fn harness_mode_enabled(&self) -> bool

Check whether harness diagnostics are enabled for this runtime instance.

Source

pub fn reactive_handler(&self) -> ReactiveHandler

Get the shared reactive handler (signal graph) for this runtime.

Source

pub async fn export_tree_ops(&self) -> Result<Vec<AttestedOp>, AgentError>

Source

pub async fn import_tree_ops( &self, ops: &[AttestedOp], ) -> Result<(), AgentError>

Source

pub fn attach_fact_sink(&self, tx: Sender<FactSource>)

Attach a fact sink for reactive scheduling (facts → scheduler ingestion).

This is called during runtime startup when the ReactivePipeline is started.

Source

pub fn attach_view_update_sender(&self, tx: Sender<ViewUpdate>)

Attach a view update sender for awaiting fact processing.

This is called during runtime startup when the ReactivePipeline is started.

Source

pub async fn await_next_view_update(&self)

Wait for the reactive scheduler to process the next batch of facts.

This is useful after committing facts to ensure the reactive views have been updated before continuing. Returns immediately if no view update subscription is available (e.g., in tests).

§Example
ⓘ
effects.commit_generic_fact_bytes(context, type_id, bytes).await?;
effects.await_next_view_update().await; // Ensure views are updated
Source

pub fn requeue_envelope(&self, envelope: TransportEnvelope)

Source

pub fn attach_lan_transport(&self, service: Arc<LanTransportService>)

Source

pub fn lan_transport(&self) -> Option<Arc<LanTransportService>>

Source

pub fn attach_rendezvous_manager(&self, manager: RendezvousManager)

Source

pub fn rendezvous_manager(&self) -> Option<RendezvousManager>

Source

pub fn attach_move_manager(&self, manager: MoveManager)

Source

pub fn move_manager(&self) -> Option<MoveManager>

Source

pub async fn initialize_biscuit_cache(&self)

Load persisted Biscuit tokens from secure storage into the in-memory cache.

Called during startup (builder) to restore tokens for returning users. For new users the cache remains empty until bootstrap_authority() creates tokens.

Storage format: [32 bytes root public key][N bytes biscuit token]

Source

pub fn set_biscuit_cache(&self, cache: BiscuitCache)

Set the biscuit cache directly (used during bootstrap_authority).

Source

pub fn biscuit_cache(&self) -> Option<BiscuitCache>

Get the current biscuit cache (for guard chain metadata).

Source

pub async fn bootstrap_biscuit_tokens( &self, authority: &AuthorityId, ) -> Result<(), AuraError>

Create and persist Biscuit authorization tokens during account bootstrap.

Creates a TokenAuthority, mints a self-token with full capabilities, persists [32 bytes root PK][N bytes token] to secure storage, and populates the in-memory BiscuitCache so the guard chain works immediately.

Source

pub async fn commit_relational_facts( &self, facts: Vec<RelationalFact>, ) -> Result<Vec<TypedFact>, AuraError>

Commit a batch of typed relational facts into the canonical fact store and publish them.

This is the single write path for UI-facing facts in the runtime.

Source

pub async fn commit_relational_facts_with_options( &self, facts: Vec<RelationalFact>, options: FactOptions, ) -> Result<Vec<TypedFact>, AuraError>

Commit a batch of typed relational facts with options.

Same as commit_relational_facts but allows specifying options like ack tracking.

Source

pub async fn commit_generic_fact_bytes( &self, context_id: ContextId, binding_type: FactTypeId, binding_data: Vec<u8>, ) -> Result<TypedFact, AuraError>

Commit a single generic domain fact (binding_type + bytes) into the canonical fact store.

Source

pub async fn load_committed_facts( &self, authority_id: AuthorityId, ) -> Result<Vec<TypedFact>, AuraError>

Load all committed typed facts for the given authority from storage.

Source

pub async fn has_dkg_transcript_commit( &self, authority_id: AuthorityId, context_id: ContextId, epoch: u64, ) -> Result<bool, AuraError>

Check whether a consensus-finalized DKG transcript commit exists for an epoch.

Source

pub async fn latest_dkg_transcript_commit( &self, authority_id: AuthorityId, context_id: ContextId, ) -> Result<Option<DkgTranscriptCommit>, AuraError>

Return the latest DKG transcript commit for a context, if any.

Source

pub fn new( config: AgentConfig, authority_id: AuthorityId, ) -> Result<Self, AgentError>

Create new effect system with configuration (testing mode).

Source

pub fn production( config: AgentConfig, authority_id: AuthorityId, ) -> Result<Self, AgentError>

Create effect system for production.

Source

pub fn simulation_for_test(config: &AgentConfig) -> Result<Self, AgentError>

Canonical deterministic constructor for tests.

Seed derivation is deterministic from callsite location, and duplicate seeds in-process are rejected to prevent hidden test coupling.

Source

pub fn simulation_for_test_with_salt( config: &AgentConfig, extra_salt: u64, ) -> Result<Self, AgentError>

Deterministic test constructor with extra salt for multi-instance setups from the same callsite.

Source

pub fn simulation_for_named_test( config: &AgentConfig, test_identity: &str, ) -> Result<Self, AgentError>

Deterministic test constructor using explicit test identity plus callsite.

Source

pub fn simulation_for_named_test_with_salt( config: &AgentConfig, test_identity: &str, extra_salt: u64, ) -> Result<Self, AgentError>

Deterministic test constructor with explicit test identity and salt.

Source

pub fn simulation_for_test_for_authority( config: &AgentConfig, authority_id: AuthorityId, ) -> Result<Self, AgentError>

Deterministic authority-aware constructor for tests.

Source

pub fn simulation_for_test_for_authority_with_salt( config: &AgentConfig, authority_id: AuthorityId, extra_salt: u64, ) -> Result<Self, AgentError>

Deterministic authority-aware constructor for tests with salt.

Source

pub fn simulation_for_test_with_shared_transport( config: &AgentConfig, shared_transport: SharedTransport, ) -> Result<Self, AgentError>

Deterministic shared-transport constructor for tests.

Source

pub fn simulation_for_test_with_shared_transport_for_authority( config: &AgentConfig, authority_id: AuthorityId, shared_transport: SharedTransport, ) -> Result<Self, AgentError>

Deterministic shared-transport constructor for tests with explicit authority.

Source

pub fn testing( config: &AgentConfig, authority_id: AuthorityId, ) -> Result<Self, AgentError>

Create effect system for testing with default configuration.

Prefer simulation_for_test(...) for deterministic per-test seeding.

Source

pub fn testing_with_shared_transport( config: &AgentConfig, authority_id: AuthorityId, shared_transport: SharedTransport, ) -> Result<Self, AgentError>

Create effect system for testing with shared transport.

This factory is used for tests that need to verify transport envelope routing, enabling loopback testing where an agent can send and receive messages from itself.

Source

pub fn simulation( config: &AgentConfig, seed: u64, authority_id: AuthorityId, ) -> Result<Self, AgentError>

Create effect system for simulation with controlled seed.

Source

pub fn simulation_with_shared_transport( config: &AgentConfig, seed: u64, authority_id: AuthorityId, shared_transport: SharedTransport, ) -> Result<Self, AgentError>

Create effect system for simulation with shared transport.

This factory is used for multi-agent simulations where all agents need to communicate through a shared transport layer. The shared transport enables message routing between Bob, Alice, and Carol in demo mode.

Source

pub fn simulation_with_shared_inbox( config: &AgentConfig, seed: u64, authority_id: AuthorityId, shared_inbox: Arc<RwLock<Vec<TransportEnvelope>>>, ) -> Result<Self, AgentError>

Create effect system for simulation with a shared inbox.

This variant matches the aura-core simulation factory contract and uses a single shared inbox for all agents. Receivers filter by destination.

Source

pub fn production_for_authority( config: AgentConfig, authority_id: AuthorityId, ) -> Result<Self, AgentError>

Create effect system for production, overriding the authority identity.

Source

pub fn testing_for_authority( config: &AgentConfig, authority_id: AuthorityId, ) -> Result<Self, AgentError>

Create effect system for testing, overriding the authority identity.

Prefer simulation_for_test_for_authority(...) for deterministic per-test seeding.

Source

pub fn simulation_for_authority( config: &AgentConfig, seed: u64, authority_id: AuthorityId, ) -> Result<Self, AgentError>

Create effect system for simulation, overriding the authority identity.

Source

pub fn simulation_with_shared_transport_for_authority( config: &AgentConfig, seed: u64, authority_id: AuthorityId, shared_transport: SharedTransport, ) -> Result<Self, AgentError>

Create effect system for simulation with shared transport, overriding authority.

Source

pub fn simulation_with_shared_inbox_for_authority( config: &AgentConfig, seed: u64, authority_id: AuthorityId, shared_inbox: Arc<RwLock<Vec<TransportEnvelope>>>, ) -> Result<Self, AgentError>

Create effect system for simulation with a shared inbox, overriding authority.

Source

pub fn config(&self) -> &AgentConfig

Get configuration

Source

pub fn composite(&self) -> &CompositeHandlerAdapter

Get composite handler

Source

pub fn time_effects(&self) -> &EnhancedTimeHandler

Get access to time effects

Source

pub fn fact_registry(&self) -> Arc<FactRegistry>

Get the fact registry for domain-specific fact reduction.

Source

pub fn indexed_journal(&self) -> Arc<IndexedJournalHandler>

Get the indexed journal handler for efficient fact lookups.

Provides O(log n) B-tree indexed lookups, O(1) Bloom filter membership tests, and Merkle tree integrity verification.

Source§

impl AuraEffectSystem

Source

pub fn device_id(&self) -> DeviceId

Source§

impl AuraEffectSystem

Source

pub async fn start_owned_choreography_session( &self, owner_label: impl Into<String>, session_uuid: Uuid, roles: Vec<ChoreographicRole>, ) -> Result<RuntimeSessionOwner, SessionIngressError>

Source

pub fn assert_owned_choreography_session( &self, owner: &RuntimeSessionOwner, ) -> Result<(), SessionIngressError>

Source

pub fn assert_owned_choreography_boundary( &self, owner: &RuntimeSessionOwner, boundary: &AuraLinkBoundary, ) -> Result<(), SessionIngressError>

Source

pub fn transfer_owned_choreography_session_owner( &self, owner: RuntimeSessionOwner, next_owner_label: impl Into<String>, next_scope: SessionOwnerCapabilityScope, ) -> Result<RuntimeSessionOwner, SessionIngressError>

Source

pub async fn end_owned_choreography_session( &self, owner: &RuntimeSessionOwner, ) -> Result<(), SessionIngressError>

Trait Implementations§

Source§

impl AmpChannelEffects for AuraEffectSystem

Source§

fn create_channel<'life0, 'async_trait>( &'life0 self, params: ChannelCreateParams, ) -> Pin<Box<dyn Future<Output = Result<ChannelId, AmpChannelError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Create a channel within a relational context. Returns the ChannelId.
Source§

fn close_channel<'life0, 'async_trait>( &'life0 self, params: ChannelCloseParams, ) -> Pin<Box<dyn Future<Output = Result<(), AmpChannelError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Close/archive a channel.
Source§

fn join_channel<'life0, 'async_trait>( &'life0 self, params: ChannelJoinParams, ) -> Pin<Box<dyn Future<Output = Result<(), AmpChannelError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Join an existing channel.
Source§

fn leave_channel<'life0, 'async_trait>( &'life0 self, params: ChannelLeaveParams, ) -> Pin<Box<dyn Future<Output = Result<(), AmpChannelError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Leave a channel.
Source§

fn send_message<'life0, 'async_trait>( &'life0 self, params: ChannelSendParams, ) -> Pin<Box<dyn Future<Output = Result<AmpCiphertext, AmpChannelError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Send a message on a channel, returning ciphertext + AMP header.
Source§

impl AuraEffects for AuraEffectSystem

Source§

fn execution_mode(&self) -> ExecutionMode

Get the execution mode of this effects implementation
Source§

impl AuthorizationEffects for AuraEffectSystem

Source§

fn verify_capability<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, capabilities: &'life1 Cap, operation: AuthorizationOp, scope: &'life2 ResourceScope, ) -> Pin<Box<dyn Future<Output = Result<bool, AuthorizationError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Verify that capabilities grant permission for a specific operation Read more
Source§

fn delegate_capabilities<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, source_capabilities: &'life1 Cap, requested_capabilities: &'life2 Cap, target_authority: &'life3 AuthorityId, ) -> Pin<Box<dyn Future<Output = Result<Cap, AuthorizationError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Delegate a subset of capabilities to another entity Read more
Source§

impl ChoreographicEffects for AuraEffectSystem

Source§

fn send_to_role_bytes<'life0, 'async_trait>( &'life0 self, role: ChoreographicRole, message: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<(), ChoreographyError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Send raw bytes to a specific role in the choreography
Source§

fn receive_from_role_bytes<'life0, 'async_trait>( &'life0 self, role: ChoreographicRole, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, ChoreographyError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Receive raw bytes from a specific role
Source§

fn broadcast_bytes<'life0, 'async_trait>( &'life0 self, message: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<(), ChoreographyError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Broadcast raw bytes to all roles
Source§

fn current_role(&self) -> ChoreographicRole

Get the current role in the choreography
Source§

fn all_roles(&self) -> Vec<ChoreographicRole>

Get all roles participating in the choreography
Source§

fn is_role_active<'life0, 'async_trait>( &'life0 self, role: ChoreographicRole, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Check if a role is currently active/connected
Source§

fn start_session<'life0, 'async_trait>( &'life0 self, session_id: Uuid, roles: Vec<ChoreographicRole>, ) -> Pin<Box<dyn Future<Output = Result<(), ChoreographyError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Start a new choreography session
Source§

fn end_session<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), ChoreographyError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

End the current choreography session
Source§

fn emit_choreo_event<'life0, 'async_trait>( &'life0 self, event: ChoreographyEvent, ) -> Pin<Box<dyn Future<Output = Result<(), ChoreographyError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Emit a choreography event for debugging/visualization
Source§

fn set_timeout<'life0, 'async_trait>( &'life0 self, timeout_ms: u64, ) -> Pin<Box<dyn Future<Output = ()> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Set a timeout for the next operation
Source§

fn get_metrics<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = ChoreographyMetrics> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get performance metrics for the choreography
Source§

impl ConsoleEffects for AuraEffectSystem

Source§

fn log_info<'life0, 'life1, 'async_trait>( &'life0 self, message: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Log an info message
Source§

fn log_warn<'life0, 'life1, 'async_trait>( &'life0 self, message: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Log a warning message
Source§

fn log_error<'life0, 'life1, 'async_trait>( &'life0 self, message: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Log an error message
Source§

fn log_debug<'life0, 'life1, 'async_trait>( &'life0 self, message: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Log a debug message
Source§

impl CryptoCoreEffects for AuraEffectSystem

Source§

fn kdf_derive<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ikm: &'life1 [u8], salt: &'life2 [u8], info: &'life3 [u8], output_len: u32, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Deterministic key derivation with explicit salt and info inputs.
Source§

fn derive_key<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, master_key: &'life1 [u8], context: &'life2 KeyDerivationContext, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Derive key using context for deterministic derivation
Source§

fn ed25519_generate_keypair<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(Vec<u8>, Vec<u8>), CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Generate Ed25519 keypair
Source§

fn ed25519_sign<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, message: &'life1 [u8], private_key: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Sign with Ed25519 private key
Source§

fn ed25519_verify<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, message: &'life1 [u8], signature: &'life2 [u8], public_key: &'life3 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Verify Ed25519 signature
Source§

fn is_simulated(&self) -> bool

Check if this crypto handler supports simulation mode
Source§

fn crypto_capabilities(&self) -> Vec<String>

Get crypto implementation capabilities
Source§

fn constant_time_eq(&self, a: &[u8], b: &[u8]) -> bool

Constant-time comparison for cryptographic values
Source§

fn secure_zero(&self, data: &mut [u8])

Securely zero memory
Source§

impl CryptoExtendedEffects for AuraEffectSystem

Source§

fn frost_generate_keys<'life0, 'async_trait>( &'life0 self, threshold: u16, max_signers: u16, ) -> Pin<Box<dyn Future<Output = Result<FrostKeyGenResult, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Source§

fn frost_generate_nonces<'life0, 'life1, 'async_trait>( &'life0 self, key_package: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn frost_create_signing_package<'life0, 'life1, 'life2, 'life3, 'life4, 'async_trait>( &'life0 self, message: &'life1 [u8], nonces: &'life2 [Vec<u8>], participants: &'life3 [u16], public_key_package: &'life4 [u8], ) -> Pin<Box<dyn Future<Output = Result<FrostSigningPackage, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait, 'life4: 'async_trait,

Source§

fn frost_sign_share<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, signing_package: &'life1 FrostSigningPackage, key_share: &'life2 [u8], nonces: &'life3 [u8], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn frost_aggregate_signatures<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, signing_package: &'life1 FrostSigningPackage, signature_shares: &'life2 [Vec<u8>], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn frost_verify<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, message: &'life1 [u8], signature: &'life2 [u8], public_key: &'life3 [u8], ) -> Pin<Box<dyn Future<Output = Result<bool, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn ed25519_public_key<'life0, 'life1, 'async_trait>( &'life0 self, private_key: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Extract public key from Ed25519 private key
Source§

fn convert_ed25519_to_x25519_public<'life0, 'life1, 'async_trait>( &'life0 self, ed25519_public_key: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<[u8; 32], CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Convert Ed25519 public key to X25519 (Curve25519) public key for Diffie-Hellman.
Source§

fn convert_ed25519_to_x25519_private<'life0, 'life1, 'async_trait>( &'life0 self, ed25519_private_key: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<[u8; 32], CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Convert Ed25519 private key (seed) to X25519 (Curve25519) private key for Diffie-Hellman.
Source§

fn chacha20_encrypt<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, plaintext: &'life1 [u8], key: &'life2 [u8; 32], nonce: &'life3 [u8; 12], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn chacha20_decrypt<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ciphertext: &'life1 [u8], key: &'life2 [u8; 32], nonce: &'life3 [u8; 12], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn aes_gcm_encrypt<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, plaintext: &'life1 [u8], key: &'life2 [u8; 32], nonce: &'life3 [u8; 12], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn aes_gcm_decrypt<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, ciphertext: &'life1 [u8], key: &'life2 [u8; 32], nonce: &'life3 [u8; 12], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

fn frost_rotate_keys<'life0, 'life1, 'async_trait>( &'life0 self, old_shares: &'life1 [Vec<u8>], old_threshold: u16, new_threshold: u16, new_max_signers: u16, ) -> Pin<Box<dyn Future<Output = Result<FrostKeyGenResult, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn generate_signing_keys<'life0, 'async_trait>( &'life0 self, threshold: u16, max_signers: u16, ) -> Pin<Box<dyn Future<Output = Result<SigningKeyGenResult, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Source§

fn generate_signing_keys_with<'life0, 'async_trait>( &'life0 self, method: KeyGenerationMethod, threshold: u16, max_signers: u16, ) -> Pin<Box<dyn Future<Output = Result<SigningKeyGenResult, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Generate signing keys with an explicit method. Read more
Source§

fn sign_with_key<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, message: &'life1 [u8], key_package: &'life2 [u8], mode: SigningMode, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Source§

fn verify_signature<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, message: &'life1 [u8], signature: &'life2 [u8], public_key_package: &'life3 [u8], mode: SigningMode, ) -> Pin<Box<dyn Future<Output = Result<bool, CryptoError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Source§

impl Debug for AuraEffectSystem

Source§

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

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

impl EffectApiEffects for AuraEffectSystem

Source§

fn append_event<'life0, 'async_trait>( &'life0 self, _event: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<(), EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Append an event to the effect_api
Source§

fn current_epoch<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the current epoch/sequence number
Source§

fn events_since<'life0, 'async_trait>( &'life0 self, _epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<u8>>, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get events since a specific epoch
Source§

fn is_device_authorized<'life0, 'life1, 'async_trait>( &'life0 self, _device_id: DeviceId, _operation: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if a device is authorized for an operation
Source§

fn update_device_activity<'life0, 'async_trait>( &'life0 self, _device_id: DeviceId, ) -> Pin<Box<dyn Future<Output = Result<(), EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Update device last seen timestamp
Source§

fn subscribe_to_events<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<EffectApiEventStream, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Subscribe to effect_api events
Source§

fn would_create_cycle<'life0, 'life1, 'async_trait>( &'life0 self, _edges: &'life1 [(Vec<u8>, Vec<u8>)], _new_edge: (Vec<u8>, Vec<u8>), ) -> Pin<Box<dyn Future<Output = Result<bool, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if adding an edge would create a cycle in the journal graph
Source§

fn find_connected_components<'life0, 'life1, 'async_trait>( &'life0 self, _edges: &'life1 [(Vec<u8>, Vec<u8>)], ) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<Vec<u8>>>, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find strongly connected components in the journal graph
Source§

fn topological_sort<'life0, 'life1, 'async_trait>( &'life0 self, _edges: &'life1 [(Vec<u8>, Vec<u8>)], ) -> Pin<Box<dyn Future<Output = Result<Vec<Vec<u8>>, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find topological ordering of nodes in the journal graph
Source§

fn shortest_path<'life0, 'life1, 'async_trait>( &'life0 self, _edges: &'life1 [(Vec<u8>, Vec<u8>)], _start: Vec<u8>, _end: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<Vec<u8>>>, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Calculate shortest path between two nodes in the journal graph
Source§

fn generate_secret<'life0, 'async_trait>( &'life0 self, length: usize, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Generate a random secret for cryptographic operations
Source§

fn hash_data<'life0, 'life1, 'async_trait>( &'life0 self, data: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<[u8; 32], EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Hash data with cryptographic hash function
Source§

fn current_timestamp<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get current timestamp (seconds since Unix epoch)
Source§

fn effect_api_device_id<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<DeviceId, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get device ID for this effect_api instance
Source§

fn new_uuid<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Uuid, EffectApiError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Generate a new UUID
Source§

impl FlowBudgetEffects for AuraEffectSystem

Source§

fn charge_flow<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, context: &'life1 ContextId, peer: &'life2 AuthorityId, cost: FlowCost, ) -> Pin<Box<dyn Future<Output = AuraResult<Receipt>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Charge a flow budget for information sent to a peer. Read more
Source§

impl GuardContextProvider for AuraEffectSystem

Source§

fn authority_id(&self) -> AuthorityId

Source§

fn get_metadata(&self, key: &str) -> Option<String>

Source§

fn execution_mode(&self) -> ExecutionMode

Source§

fn can_perform_operation(&self, _operation: &str) -> bool

Source§

impl IndexedJournalEffects for AuraEffectSystem

Source§

fn watch_facts(&self) -> Box<dyn FactStreamReceiver>

Subscribe to journal fact updates as they are added. Read more
Source§

fn facts_by_predicate<'life0, 'life1, 'async_trait>( &'life0 self, predicate: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<IndexedFact>, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all facts with the given predicate/key. Read more
Source§

fn facts_by_authority<'life0, 'life1, 'async_trait>( &'life0 self, authority: &'life1 AuthorityId, ) -> Pin<Box<dyn Future<Output = Result<Vec<IndexedFact>, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get all facts created by the given authority. Read more
Source§

fn facts_in_range<'life0, 'async_trait>( &'life0 self, start: TimeStamp, end: TimeStamp, ) -> Pin<Box<dyn Future<Output = Result<Vec<IndexedFact>, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get all facts within the given time range (inclusive). Read more
Source§

fn all_facts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<IndexedFact>, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Return all indexed facts (append-only view).
Source§

fn might_contain(&self, predicate: &str, value: &FactValue) -> bool

Fast membership test using Bloom filter. Read more
Source§

fn merkle_root<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<[u8; 32], AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the Merkle root commitment for the current index state. Read more
Source§

fn verify_fact_inclusion<'life0, 'life1, 'async_trait>( &'life0 self, fact: &'life1 IndexedFact, ) -> Pin<Box<dyn Future<Output = Result<bool, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Verify a fact against the Merkle tree. Read more
Source§

fn get_bloom_filter<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<BloomFilter, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the Bloom filter for fast membership tests. Read more
Source§

fn index_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<IndexStats, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get statistics about the index.
Source§

impl JournalEffects for AuraEffectSystem

Source§

fn merge_facts<'life0, 'async_trait>( &'life0 self, target: Journal, delta: Journal, ) -> Pin<Box<dyn Future<Output = Result<Journal, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Merge facts using join semilattice operation Read more
Source§

fn refine_caps<'life0, 'async_trait>( &'life0 self, target: Journal, refinement: Journal, ) -> Pin<Box<dyn Future<Output = Result<Journal, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Refine capabilities using meet semilattice operation
Source§

fn get_journal<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Journal, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get current journal state
Source§

fn persist_journal<'life0, 'life1, 'async_trait>( &'life0 self, journal: &'life1 Journal, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Persist journal state
Source§

fn get_flow_budget<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _context: &'life1 ContextId, _peer: &'life2 AuthorityId, ) -> Pin<Box<dyn Future<Output = Result<FlowBudget, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get FlowBudget for a (context, peer) pair
Source§

fn update_flow_budget<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, _context: &'life1 ContextId, _peer: &'life2 AuthorityId, budget: &'life3 FlowBudget, ) -> Pin<Box<dyn Future<Output = Result<FlowBudget, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Update FlowBudget for a (context, peer) pair using CRDT merge
Source§

fn charge_flow_budget<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _context: &'life1 ContextId, _peer: &'life2 AuthorityId, _cost: FlowCost, ) -> Pin<Box<dyn Future<Output = Result<FlowBudget, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Charge flow budget and return updated budget This is an atomic operation that checks headroom and charges if possible
Source§

impl LeakageEffects for AuraEffectSystem

Source§

fn record_leakage<'life0, 'async_trait>( &'life0 self, event: LeakageEvent, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Record a leakage event
Source§

fn get_leakage_budget<'life0, 'async_trait>( &'life0 self, context_id: ContextId, ) -> Pin<Box<dyn Future<Output = Result<LeakageBudget>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get current leakage budget for a context
Source§

fn check_leakage_budget<'life0, 'async_trait>( &'life0 self, context_id: ContextId, observer: ObserverClass, amount: u64, ) -> Pin<Box<dyn Future<Output = Result<bool>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Check if operation would exceed budget
Source§

fn get_leakage_history<'life0, 'life1, 'async_trait>( &'life0 self, context_id: ContextId, since_timestamp: Option<&'life1 PhysicalTime>, ) -> Pin<Box<dyn Future<Output = Result<Vec<LeakageEvent>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get leakage history for analysis Read more
Source§

impl LogicalClockEffects for AuraEffectSystem

Source§

fn logical_advance<'life0, 'life1, 'async_trait>( &'life0 self, observed: Option<&'life1 VectorClock>, ) -> Pin<Box<dyn Future<Output = Result<LogicalTime, TimeError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Source§

fn logical_now<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<LogicalTime, TimeError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Source§

impl NetworkCoreEffects for AuraEffectSystem

Source§

fn send_to_peer<'life0, 'async_trait>( &'life0 self, peer_id: Uuid, message: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Send a message to a specific peer. Read more
Source§

fn broadcast<'life0, 'async_trait>( &'life0 self, message: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Broadcast a message to all connected peers
Source§

fn receive<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(Uuid, Vec<u8>), NetworkError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Receive the next available message
Source§

impl NetworkExtendedEffects for AuraEffectSystem

Source§

fn receive_from<'life0, 'async_trait>( &'life0 self, _peer_id: Uuid, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, NetworkError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Receive message from a specific peer authority UUID on the wire.
Source§

fn connected_peers<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Vec<Uuid>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get currently connected peer authority UUIDs on the wire.
Source§

fn is_peer_connected<'life0, 'async_trait>( &'life0 self, _peer_id: Uuid, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Check if a peer authority UUID is connected.
Source§

fn subscribe_to_peer_events<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<PeerEventStream, NetworkError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Subscribe to peer connection events
Source§

fn open<'life0, 'life1, 'async_trait>( &'life0 self, _address: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<String, NetworkError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Open a connection to the specified address Read more
Source§

fn send<'life0, 'life1, 'async_trait>( &'life0 self, _connection_id: &'life1 str, _data: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Send data over an established connection Read more
Source§

fn close<'life0, 'life1, 'async_trait>( &'life0 self, _connection_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), NetworkError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Close an established connection Read more
Source§

impl NoiseEffects for AuraEffectSystem

Source§

fn create_handshake_state<'life0, 'async_trait>( &'life0 self, params: NoiseParams, ) -> Pin<Box<dyn Future<Output = Result<HandshakeState, NoiseError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Create a new handshake state machine (Initiator or Responder). Uses Noise_IKpsk2_25519_ChaChaPoly_BLAKE2s.
Source§

fn write_message<'life0, 'life1, 'async_trait>( &'life0 self, state: HandshakeState, payload: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<(Vec<u8>, HandshakeState), NoiseError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Write a handshake message. Returns the encrypted payload and the updated state.
Source§

fn read_message<'life0, 'life1, 'async_trait>( &'life0 self, state: HandshakeState, message: &'life1 [u8], ) -> Pin<Box<dyn Future<Output = Result<(Vec<u8>, HandshakeState), NoiseError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Read a handshake message. Returns the decrypted payload and the updated state.
Source§

fn into_transport_mode<'life0, 'async_trait>( &'life0 self, state: HandshakeState, ) -> Pin<Box<dyn Future<Output = Result<TransportState, NoiseError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Transition to transport mode (Split). Returns the TransportState representing the secure channel pair.
Source§

fn encrypt_transport_message<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, state: &'life1 mut TransportState, payload: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, NoiseError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Encrypt a message using the TransportState. This is for post-handshake communication. Note: Typical Noise usage splits into two CipherStates (send/recv). This abstraction assumes the implementation handles the pair.
Source§

fn decrypt_transport_message<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, state: &'life1 mut TransportState, message: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, NoiseError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Decrypt a message using the TransportState.
Source§

impl OrderClockEffects for AuraEffectSystem

Source§

fn order_time<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<OrderTime, TimeError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Source§

impl PhysicalTimeEffects for AuraEffectSystem

Source§

fn physical_time<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<PhysicalTime, TimeError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Source§

fn sleep_ms<'life0, 'async_trait>( &'life0 self, ms: u64, ) -> Pin<Box<dyn Future<Output = Result<(), TimeError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Source§

impl RandomCoreEffects for AuraEffectSystem

Source§

fn random_bytes<'life0, 'async_trait>( &'life0 self, len: usize, ) -> Pin<Box<dyn Future<Output = Vec<u8>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Generate random bytes of specified length
Source§

fn random_bytes_32<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = [u8; 32]> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Generate 32 random bytes as array
Source§

fn random_u64<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = u64> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Generate a random u64 value
Source§

impl SecureStorageEffects for AuraEffectSystem

Source§

fn secure_store<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, location: &'life1 SecureStorageLocation, key: &'life2 [u8], caps: &'life3 [SecureStorageCapability], ) -> Pin<Box<dyn Future<Output = Result<(), SecureStorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Store data securely with optional capabilities Read more
Source§

fn secure_retrieve<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, location: &'life1 SecureStorageLocation, caps: &'life2 [SecureStorageCapability], ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, SecureStorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Retrieve data from secure storage Read more
Source§

fn secure_delete<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, location: &'life1 SecureStorageLocation, caps: &'life2 [SecureStorageCapability], ) -> Pin<Box<dyn Future<Output = Result<(), SecureStorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete data from secure storage Read more
Source§

fn secure_exists<'life0, 'life1, 'async_trait>( &'life0 self, location: &'life1 SecureStorageLocation, ) -> Pin<Box<dyn Future<Output = Result<bool, SecureStorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if data exists at the given location Read more
Source§

fn secure_list_keys<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, namespace: &'life1 str, caps: &'life2 [SecureStorageCapability], ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, SecureStorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

List available keys in a namespace Read more
Source§

fn secure_generate_key<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, location: &'life1 SecureStorageLocation, context: &'life2 str, caps: &'life3 [SecureStorageCapability], ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, SecureStorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Generate and store a new cryptographic key Read more
Source§

fn secure_create_time_bound_token<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, location: &'life1 SecureStorageLocation, caps: &'life2 [SecureStorageCapability], expires_at: &'life3 PhysicalTime, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, SecureStorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Create a time-bound access token Read more
Source§

fn secure_access_with_token<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, token: &'life1 [u8], location: &'life2 SecureStorageLocation, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, SecureStorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Use a time-bound token to access data Read more
Source§

fn get_device_attestation<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, SecureStorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get device attestation for secure operations Read more
Source§

fn is_secure_storage_available<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Check if secure storage is available Read more
Source§

fn get_secure_storage_capabilities(&self) -> Vec<String>

Get secure storage capabilities Read more
Source§

impl StorageCoreEffects for AuraEffectSystem

Source§

fn store<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, value: Vec<u8>, ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Store a value under the given key
Source§

fn retrieve<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>, StorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve a value by key
Source§

fn remove<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, StorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Remove a key-value pair
Source§

fn list_keys<'life0, 'life1, 'async_trait>( &'life0 self, prefix: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<String>, StorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

List all keys with optional prefix filter
Source§

impl StorageExtendedEffects for AuraEffectSystem

Source§

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, StorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if a key exists
Source§

fn store_batch<'life0, 'async_trait>( &'life0 self, pairs: HashMap<String, Vec<u8>>, ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Store multiple key-value pairs atomically
Source§

fn retrieve_batch<'life0, 'life1, 'async_trait>( &'life0 self, keys: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, Vec<u8>>, StorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Retrieve multiple values by keys
Source§

fn clear_all<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), StorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Clear all stored data
Source§

fn stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<StorageStats, StorageError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get storage statistics
Source§

impl SyncEffects for AuraEffectSystem

Source§

fn sync_with_peer<'life0, 'async_trait>( &'life0 self, peer_id: DeviceId, ) -> Pin<Box<dyn Future<Output = Result<SyncMetrics, SyncError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Perform anti-entropy sync with a peer Read more
Source§

fn get_oplog_digest<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<BloomDigest, SyncError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get digest of local OpLog Read more
Source§

fn get_missing_ops<'life0, 'life1, 'async_trait>( &'life0 self, remote_digest: &'life1 BloomDigest, ) -> Pin<Box<dyn Future<Output = Result<Vec<AttestedOp>, SyncError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get operations missing from remote digest Read more
Source§

fn request_ops_from_peer<'life0, 'async_trait>( &'life0 self, peer_id: DeviceId, cids: Vec<Hash32>, ) -> Pin<Box<dyn Future<Output = Result<Vec<AttestedOp>, SyncError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Request specific operations from a peer Read more
Source§

fn merge_remote_ops<'life0, 'async_trait>( &'life0 self, ops: Vec<AttestedOp>, ) -> Pin<Box<dyn Future<Output = Result<(), SyncError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Merge remote operations into local OpLog Read more
Source§

fn announce_new_op<'life0, 'async_trait>( &'life0 self, cid: Hash32, ) -> Pin<Box<dyn Future<Output = Result<(), SyncError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Announce a newly created operation to immediate peers Read more
Source§

fn request_op<'life0, 'async_trait>( &'life0 self, peer_id: DeviceId, cid: Hash32, ) -> Pin<Box<dyn Future<Output = Result<AttestedOp, SyncError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Request a specific operation by CID Read more
Source§

fn push_op_to_peers<'life0, 'async_trait>( &'life0 self, op: AttestedOp, peers: Vec<DeviceId>, ) -> Pin<Box<dyn Future<Output = Result<(), SyncError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Push an operation to specific peers Read more
Source§

fn get_connected_peers<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<DeviceId>, SyncError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get list of currently connected peers Read more
Source§

impl SystemEffects for AuraEffectSystem

Source§

fn shutdown<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), SystemError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Shutdown the system gracefully
Source§

fn get_system_info<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, String>, SystemError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get system information and status
Source§

fn log<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, level: &'life1 str, component: &'life2 str, message: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<(), SystemError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Log a message at the specified level
Source§

fn log_with_context<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, level: &'life1 str, component: &'life2 str, message: &'life3 str, _context: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<(), SystemError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Log a message with additional context
Source§

fn set_config<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _key: &'life1 str, _value: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), SystemError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Set a configuration value
Source§

fn get_config<'life0, 'life1, 'async_trait>( &'life0 self, _key: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<String, SystemError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a configuration value
Source§

fn health_check<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool, SystemError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Perform a health check
Source§

fn get_metrics<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<String, f64>, SystemError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get system metrics
Source§

fn restart_component<'life0, 'life1, 'async_trait>( &'life0 self, _component: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), SystemError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Restart a system component
Source§

impl ThresholdSigningEffects for AuraEffectSystem

Source§

fn bootstrap_authority<'life0, 'life1, 'async_trait>( &'life0 self, authority: &'life1 AuthorityId, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Bootstrap a new authority with 1-of-1 keys Read more
Source§

fn sign<'life0, 'async_trait>( &'life0 self, context: SigningContext, ) -> Pin<Box<dyn Future<Output = Result<ThresholdSignature, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Sign an operation with threshold keys Read more
Source§

fn threshold_config<'life0, 'life1, 'async_trait>( &'life0 self, authority: &'life1 AuthorityId, ) -> Pin<Box<dyn Future<Output = Option<ThresholdConfig>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the threshold configuration for an authority Read more
Source§

fn threshold_state<'life0, 'life1, 'async_trait>( &'life0 self, authority: &'life1 AuthorityId, ) -> Pin<Box<dyn Future<Output = Option<ThresholdState>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the full threshold state for an authority Read more
Source§

fn has_signing_capability<'life0, 'life1, 'async_trait>( &'life0 self, authority: &'life1 AuthorityId, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if this service can sign for an authority Read more
Source§

fn public_key_package<'life0, 'life1, 'async_trait>( &'life0 self, authority: &'life1 AuthorityId, ) -> Pin<Box<dyn Future<Output = Option<Vec<u8>>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get the public key package for an authority Read more
Source§

fn rotate_keys<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, authority: &'life1 AuthorityId, new_threshold: u16, new_total_participants: u16, participants: &'life2 [ParticipantIdentity], ) -> Pin<Box<dyn Future<Output = Result<(u64, Vec<Vec<u8>>, Vec<u8>), AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Rotate threshold keys to a new configuration Read more
Source§

fn commit_key_rotation<'life0, 'life1, 'async_trait>( &'life0 self, authority: &'life1 AuthorityId, new_epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Commit a pending key rotation Read more
Source§

fn rollback_key_rotation<'life0, 'life1, 'async_trait>( &'life0 self, authority: &'life1 AuthorityId, failed_epoch: u64, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Rollback a pending key rotation Read more
Source§

impl TimeEffects for AuraEffectSystem

Source§

fn current_timestamp<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = u64> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: Sync + 'async_trait,

Current Unix timestamp in seconds.
Source§

fn current_timestamp_ms<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = u64> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: Sync + 'async_trait,

Current Unix timestamp in milliseconds.
Source§

fn current_epoch<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = u64> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: Sync + 'async_trait,

Alias for current epoch seconds.
Source§

impl TransportEffects for AuraEffectSystem

Source§

fn send_envelope<'life0, 'async_trait>( &'life0 self, envelope: TransportEnvelope, ) -> Pin<Box<dyn Future<Output = Result<(), TransportError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Send an envelope to a destination authority Read more
Source§

fn receive_envelope<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<TransportEnvelope, TransportError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Receive the next available envelope Read more
Source§

fn receive_envelope_from<'life0, 'async_trait>( &'life0 self, source: AuthorityId, context: ContextId, ) -> Pin<Box<dyn Future<Output = Result<TransportEnvelope, TransportError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Receive envelope from a specific authority within a context Read more
Source§

fn is_channel_established<'life0, 'async_trait>( &'life0 self, context: ContextId, peer: AuthorityId, ) -> Pin<Box<dyn Future<Output = bool> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Check if a secure channel is established for the given context and peer
Source§

fn get_transport_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = TransportStats> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get statistics about transport operation
Source§

impl TreeEffects for AuraEffectSystem

Source§

fn get_current_state<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<JournalTreeState, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the current tree state Read more
Source§

fn get_current_commitment<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Hash32, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the current root commitment Read more
Source§

fn get_current_epoch<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Epoch, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Get the current epoch Read more
Source§

fn apply_attested_op<'life0, 'async_trait>( &'life0 self, op: AttestedOp, ) -> Pin<Box<dyn Future<Output = Result<Hash32, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Apply an attested tree operation Read more
Source§

fn verify_aggregate_sig<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, op: &'life1 AttestedOp, state: &'life2 JournalTreeState, ) -> Pin<Box<dyn Future<Output = Result<bool, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Verify an aggregate signature Read more
Source§

fn add_leaf<'life0, 'async_trait>( &'life0 self, leaf: LeafNode, under: NodeIndex, ) -> Pin<Box<dyn Future<Output = Result<TreeOpKind, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Propose adding a leaf to the tree Read more
Source§

fn remove_leaf<'life0, 'async_trait>( &'life0 self, leaf_id: LeafId, reason: u8, ) -> Pin<Box<dyn Future<Output = Result<TreeOpKind, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Propose removing a leaf from the tree Read more
Source§

fn change_policy<'life0, 'async_trait>( &'life0 self, node: NodeIndex, policy: Policy, ) -> Pin<Box<dyn Future<Output = Result<TreeOpKind, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Propose changing a node’s policy Read more
Source§

fn rotate_epoch<'life0, 'async_trait>( &'life0 self, affected: Vec<NodeIndex>, ) -> Pin<Box<dyn Future<Output = Result<TreeOpKind, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Propose rotating the epoch Read more
Source§

fn propose_snapshot<'life0, 'async_trait>( &'life0 self, cut: Cut, ) -> Pin<Box<dyn Future<Output = Result<ProposalId, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Propose a snapshot at a specific cut point Read more
Source§

fn approve_snapshot<'life0, 'async_trait>( &'life0 self, proposal_id: ProposalId, ) -> Pin<Box<dyn Future<Output = Result<Partial, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Add partial approval to a snapshot proposal Read more
Source§

fn finalize_snapshot<'life0, 'async_trait>( &'life0 self, proposal_id: ProposalId, ) -> Pin<Box<dyn Future<Output = Result<Snapshot, AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Finalize a snapshot after threshold approval Read more
Source§

fn apply_snapshot<'life0, 'life1, 'async_trait>( &'life0 self, snapshot: &'life1 Snapshot, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Apply a snapshot to local state Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<E> AmpEvidenceEffects for E
where E: StorageEffects,

Source§

fn merge_evidence_delta<'life0, 'async_trait>( &'life0 self, cid: ConsensusId, delta: EvidenceDelta, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where 'life0: 'async_trait, E: 'async_trait,

Carry evidence deltas keyed by consensus id.
Source§

fn evidence_for<'life0, 'async_trait>( &'life0 self, cid: ConsensusId, ) -> Pin<Box<dyn Future<Output = Result<Option<EvidenceRecord>, AuraError>> + Send + 'async_trait>>
where 'life0: 'async_trait, E: 'async_trait,

Retrieve accumulated evidence for a consensus id.
Source§

fn insert_evidence_delta<'life0, 'async_trait>( &'life0 self, witness: AuthorityId, consensus_id: ConsensusId, context: ContextId, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where 'life0: 'async_trait, E: 'async_trait,

Insert evidence delta tracking witness participation in consensus.
Source§

fn evidence_store(&self) -> AmpEvidenceStore<'_, Self>
where Self: Sized,

Scoped evidence store wrapper to keep evidence handling separate.
Source§

impl<E> AmpJournalEffects for E
where E: JournalEffects + OrderClockEffects,

Source§

fn fetch_context_journal<'life0, 'async_trait>( &'life0 self, context: ContextId, ) -> Pin<Box<dyn Future<Output = Result<Journal, AuraError>> + Send + 'async_trait>>
where 'life0: 'async_trait, E: 'async_trait,

Fetch the full context journal (fact-based) for reduction.
Source§

fn insert_relational_fact<'life0, 'async_trait>( &'life0 self, fact: RelationalFact, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where 'life0: 'async_trait, E: 'async_trait,

Insert a relational fact (AMP checkpoint/bump/policy/evidence).
Source§

fn context_store(&self) -> AmpContextStore<'_, Self>
where Self: Sized,

Scoped context store wrapper to avoid leaking storage keys.
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> Az for T

Source§

fn az<Dst>(self) -> Dst
where T: Cast<Dst>,

Casts the value.
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<Src, Dst> CastFrom<Src> for Dst
where Src: Cast<Dst>,

Source§

fn cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T> CheckedAs for T

Source§

fn checked_as<Dst>(self) -> Option<Dst>
where T: CheckedCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> CheckedCastFrom<Src> for Dst
where Src: CheckedCast<Dst>,

Source§

fn checked_cast_from(src: Src) -> Option<Dst>

Casts the value.
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T> Instrument for T

Source§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
Source§

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.

Source§

impl<T> IntoEither for T

Source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
Source§

impl<T> IntoViewDelta for T
where T: Any + Send + Sync,

Source§

fn into_view_delta(self) -> Box<dyn Any + Send + Sync>

Convert self into a type-erased ViewDelta.
Source§

impl<T> LeakageChoreographyExt for T
where T: LeakageEffects,

Source§

fn record_send_leakage<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, source: AuthorityId, destination: AuthorityId, context_id: ContextId, flow_cost: u64, observer_classes: &'life1 [ObserverClass], timestamp: &'life2 PhysicalTime, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Record leakage for a send operation Read more
Source§

fn record_recv_leakage<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, source: AuthorityId, destination: AuthorityId, context_id: ContextId, flow_cost: u64, observer_classes: &'life1 [ObserverClass], timestamp: &'life2 PhysicalTime, ) -> Pin<Box<dyn Future<Output = Result<(), AuraError>> + Send + 'async_trait>>
where 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, Self: Sync + 'async_trait,

Record leakage for a receive operation Read more
Source§

impl<Src, Dst> LosslessTryInto<Dst> for Src
where Dst: LosslessTryFrom<Src>,

Source§

fn lossless_try_into(self) -> Option<Dst>

Performs the conversion.
Source§

impl<Src, Dst> LossyInto<Dst> for Src
where Dst: LossyFrom<Src>,

Source§

fn lossy_into(self) -> Dst

Performs the conversion.
Source§

impl<T> OverflowingAs for T

Source§

fn overflowing_as<Dst>(self) -> (Dst, bool)
where T: OverflowingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> OverflowingCastFrom<Src> for Dst
where Src: OverflowingCast<Dst>,

Source§

fn overflowing_cast_from(src: Src) -> (Dst, bool)

Casts the value.
Source§

impl<T> Pointable for T

Source§

const ALIGN: usize

The alignment of pointer.
Source§

type Init = T

The type for initializers.
Source§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

impl<T> RandomExtendedEffects for T
where T: RandomCoreEffects + ?Sized,

Source§

fn random_range<'life0, 'async_trait>( &'life0 self, min: u64, max: u64, ) -> Pin<Box<dyn Future<Output = u64> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: 'async_trait,

Generate a random number in the specified range
Source§

fn random_uuid<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Uuid> + Send + 'async_trait>>
where 'life0: 'async_trait, Self: 'async_trait,

Generate a random UUID v4
Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T> SaturatingAs for T

Source§

fn saturating_as<Dst>(self) -> Dst
where T: SaturatingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> SaturatingCastFrom<Src> for Dst
where Src: SaturatingCast<Dst>,

Source§

fn saturating_cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T> StrictAs for T

Source§

fn strict_as<Dst>(self) -> Dst
where T: StrictCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> StrictCastFrom<Src> for Dst
where Src: StrictCast<Dst>,

Source§

fn strict_cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

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>,

Source§

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

impl<T> UnwrappedAs for T

Source§

fn unwrapped_as<Dst>(self) -> Dst
where T: UnwrappedCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> UnwrappedCastFrom<Src> for Dst
where Src: UnwrappedCast<Dst>,

Source§

fn unwrapped_cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<S, T> Upcast<T> for S
where T: UpcastFrom<S> + ?Sized, S: ?Sized,

Source§

fn upcast(&self) -> &T
where Self: ErasableGeneric, T: ErasableGeneric<Repr = Self::Repr>,

Perform a zero-cost type-safe upcast to a wider ref type within the Wasm bindgen generics type system. Read more
Source§

fn upcast_into(self) -> T
where Self: Sized + ErasableGeneric, T: ErasableGeneric<Repr = Self::Repr>,

Perform a zero-cost type-safe upcast to a wider type within the Wasm bindgen generics type system. Read more
Source§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

fn vzip(self) -> V

Source§

impl<T> WithSubscriber for T

Source§

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

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
Source§

impl<T> WrappingAs for T

Source§

fn wrapping_as<Dst>(self) -> Dst
where T: WrappingCast<Dst>,

Casts the value.
Source§

impl<Src, Dst> WrappingCastFrom<Src> for Dst
where Src: WrappingCast<Dst>,

Source§

fn wrapping_cast_from(src: Src) -> Dst

Casts the value.
Source§

impl<T> AmpEffects for T
where T: AmpJournalEffects + OrderClockEffects + RandomEffects + PhysicalTimeEffects + GuardEffects + GuardContextProvider + NetworkEffects + CryptoEffects,

Source§

impl<T> AntiEntropyEffects for T
where T: NetworkEffects + CryptoEffects + RandomEffects + ConsoleEffects,

Source§

impl<T> AntiEntropyProtocolEffects for T
where T: GuardChainEffects + TransportEffects,

Source§

impl<T> ChoreographyEffects for T
where T: NetworkEffects + CryptoEffects + RandomEffects + PhysicalTimeEffects + StorageEffects + JournalEffects + ConsoleEffects,

Source§

impl<T> ConsensusEffects for T
where T: RandomEffects + PhysicalTimeEffects,

Source§

impl<T> CrdtEffects for T
where T: StorageEffects + JournalEffects + ConsoleEffects,

Source§

impl<T> CryptoEffects for T
where T: CryptoCoreEffects + CryptoExtendedEffects + ?Sized,

Source§

impl<T> Endpoint for T
where T: Send,

Source§

impl<T> GuardChainEffects for T
where T: GuardEffects + GuardContextProvider + PhysicalTimeEffects,

Source§

impl<T> GuardEffects for T
where T: JournalEffects + StorageEffects + FlowBudgetEffects + PhysicalTimeEffects + RandomEffects + AuthorizationEffects + LeakageEffects + Send + Sync,

Source§

impl<T> GuardsEffects for T
where T: GuardEffects + GuardContextProvider + PhysicalTimeEffects,

Source§

impl<T> InvitationCeremonyEffects for T
where T: JournalEffects + PhysicalTimeEffects + ThresholdSigningEffects + Send + Sync,

Source§

impl<T> MinimalEffects for T
where T: CryptoEffects + RandomEffects + ConsoleEffects,

Source§

impl<T> NetworkEffects for T
where T: NetworkCoreEffects + NetworkExtendedEffects + ?Sized,

Source§

impl<T> ProtocolEffects for T
where T: GuardEffects + GuardContextProvider + PhysicalTimeEffects + FlowBudgetEffects + JournalEffects + LeakageEffects + TransportEffects,

Source§

impl<T> RandomEffects for T
where T: RandomCoreEffects + RandomExtendedEffects + ?Sized,

Source§

impl<T> RecoveryCeremonyEffects for T
where T: JournalEffects + PhysicalTimeEffects + ThresholdSigningEffects + Send + Sync,

Source§

impl<T> RecoveryEffects for T
where T: PhysicalTimeEffects + CryptoEffects + JournalEffects + RandomEffects + ThresholdSigningEffects + StorageEffects + SecureStorageEffects + Send + Sync,

Source§

impl<T> RecoveryNetworkEffects for T
where T: RecoveryEffects + NetworkEffects,

Source§

impl<T> SigningEffects for T
where T: NetworkEffects + CryptoEffects + PhysicalTimeEffects + ConsoleEffects,

Source§

impl<T> SnapshotEffects for T
where T: NetworkEffects + CryptoEffects + PhysicalTimeEffects + StorageEffects + JournalEffects + ConsoleEffects,

Source§

impl<T> StorageEffects for T
where T: StorageCoreEffects + StorageExtendedEffects + ?Sized,

Source§

impl<T> SyncCoreJournalEffects for T
where T: JournalEffects + Send + Sync,

Source§

impl<T> SyncCoreProtocolEffects for T
where T: SyncCoreJournalEffects + NetworkEffects + PhysicalTimeEffects,

Source§

impl<T> SyncJournalEffects for T
where T: JournalEffects + Send + Sync,

Source§

impl<T> SyncProtocolEffects for T
where T: SyncJournalEffects + NetworkEffects + PhysicalTimeEffects + GuardContextProvider,

Source§

impl<T> TreeEffects for T
where T: NetworkEffects + CryptoEffects + PhysicalTimeEffects + StorageEffects + ConsoleEffects,