SYMBOL INDEX (3271 symbols across 285 files) FILE: common/db/src/create_db.rs function serai_db_key (line 2) | pub fn serai_db_key( FILE: common/db/src/lib.rs type Get (line 18) | pub trait Get { method get (line 19) | fn get(&self, key: impl AsRef<[u8]>) -> Option>; type DbTxn (line 24) | pub trait DbTxn: Send + Get { method put (line 25) | fn put(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>); method del (line 26) | fn del(&mut self, key: impl AsRef<[u8]>); method commit (line 27) | fn commit(self); type Db (line 31) | pub trait Db: 'static + Send + Sync + Clone + Get { method key (line 33) | fn key(db_dst: &'static [u8], item_dst: &'static [u8], key: impl AsRef... method txn (line 38) | fn txn(&mut self) -> Self::Transaction<'_>; FILE: common/db/src/mem.rs type MemDbTxn (line 12) | pub struct MemDbTxn<'a>(&'a MemDb, HashMap, Vec>, HashSet) -> Option> { method put (line 27) | fn put(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>) { method del (line 31) | fn del(&mut self, key: impl AsRef<[u8]>) { method commit (line 35) | fn commit(mut self) { type MemDb (line 48) | pub struct MemDb(Arc, Vec>>>); method new (line 65) | pub fn new() -> MemDb { method eq (line 51) | fn eq(&self, other: &MemDb) -> bool { method default (line 58) | fn default() -> MemDb { method get (line 71) | fn get(&self, key: impl AsRef<[u8]>) -> Option> { type Transaction (line 76) | type Transaction<'a> = MemDbTxn<'a>; method txn (line 77) | fn txn(&mut self) -> MemDbTxn<'_> { FILE: common/db/src/parity_db.rs type Transaction (line 8) | pub struct Transaction<'a>(&'a Arc, Vec<(u8, Vec, Option) -> Option> { method put (line 22) | fn put(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>) { method del (line 25) | fn del(&mut self, key: impl AsRef<[u8]>) { method commit (line 28) | fn commit(self) { method get (line 34) | fn get(&self, key: impl AsRef<[u8]>) -> Option> { type Transaction (line 39) | type Transaction<'a> = Transaction<'a>; method txn (line 40) | fn txn(&mut self) -> Self::Transaction<'_> { function new_parity_db (line 45) | pub fn new_parity_db(path: &str) -> Arc { FILE: common/db/src/rocks.rs type Transaction (line 11) | pub struct Transaction<'a, T: ThreadMode>( method get (line 17) | fn get(&self, key: impl AsRef<[u8]>) -> Option> { method put (line 22) | fn put(&mut self, key: impl AsRef<[u8]>, value: impl AsRef<[u8]>) { method del (line 25) | fn del(&mut self, key: impl AsRef<[u8]>) { method commit (line 28) | fn commit(self) { method get (line 36) | fn get(&self, key: impl AsRef<[u8]>) -> Option> { type Transaction (line 41) | type Transaction<'a> = Transaction<'a, T>; method txn (line 42) | fn txn(&mut self) -> Self::Transaction<'_> { type RocksDB (line 49) | pub type RocksDB = Arc>; function new_rocksdb (line 50) | pub fn new_rocksdb(path: &str) -> RocksDB { FILE: common/env/src/lib.rs function var (line 4) | pub fn var(variable: &str) -> Option { FILE: common/patchable-async-sleep/src/lib.rs function sleep (line 8) | pub fn sleep(duration: Duration) -> impl core::future::Future; type Connection (line 40) | enum Connection { type Client (line 50) | pub struct Client { method connector (line 55) | fn connector() -> Connector { method with_connection_pool (line 72) | pub fn with_connection_pool() -> Client { method without_connection_pool (line 82) | pub fn without_connection_pool(host: &str) -> Result { method request (line 98) | pub async fn request>(&self, request: R) -> Result>); method username_password_from_uri (line 13) | fn username_password_from_uri(&self) -> Result<(String, String), Error> { method basic_auth (line 32) | pub fn basic_auth(&mut self, username: &str, password: &str) { method basic_auth_from_uri (line 47) | pub fn basic_auth_from_uri(&mut self) -> Result<(), Error> { method with_basic_auth (line 59) | pub fn with_basic_auth(&mut self) { method from (line 64) | fn from(request: hyper::Request>) -> Request { FILE: common/request/src/response.rs type Response (line 13) | pub struct Response<'a>(pub(crate) hyper::Response, pub(crate)... function status (line 15) | pub fn status(&self) -> StatusCode { function headers (line 18) | pub fn headers(&self) -> &HeaderMap { function body (line 21) | pub async fn body(self) -> Result { FILE: common/std-shims/src/io.rs type ErrorKind (line 10) | pub enum ErrorKind { type Error (line 15) | pub struct Error { method new (line 27) | pub fn new(kind: ErrorKind, error: E) -> Err... method other (line 31) | pub fn other(error: E) -> Error { method kind (line 35) | pub fn kind(&self) -> ErrorKind { method into_inner (line 39) | pub fn into_inner(self) -> Option> { method fmt (line 21) | fn fmt(&self, fmt: &mut Formatter<'_>) -> core::result::Result<(), core:... type Result (line 44) | pub type Result = core::result::Result; type Read (line 46) | pub trait Read { method read (line 47) | fn read(&mut self, buf: &mut [u8]) -> Result; method read_exact (line 49) | fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> { method read (line 59) | fn read(&mut self, buf: &mut [u8]) -> Result { type BufRead (line 67) | pub trait BufRead: Read { method fill_buf (line 68) | fn fill_buf(&mut self) -> Result<&[u8]>; method consume (line 69) | fn consume(&mut self, amt: usize); method fill_buf (line 73) | fn fill_buf(&mut self) -> Result<&[u8]> { method consume (line 76) | fn consume(&mut self, amt: usize) { type Write (line 81) | pub trait Write { method write (line 82) | fn write(&mut self, buf: &[u8]) -> Result; method write_all (line 83) | fn write_all(&mut self, buf: &[u8]) -> Result<()> { method write (line 92) | fn write(&mut self, buf: &[u8]) -> Result { FILE: common/std-shims/src/lib.rs type StdShimsDivCeil (line 18) | pub trait StdShimsDivCeil { method div_ceil (line 19) | fn div_ceil(self, rhs: Self) -> Self; method div_ceil (line 25) | fn div_ceil(self, rhs: Self) -> Self { method div_ceil (line 30) | fn div_ceil(self, rhs: Self) -> Self { method div_ceil (line 35) | fn div_ceil(self, rhs: Self) -> Self { method div_ceil (line 40) | fn div_ceil(self, rhs: Self) -> Self { method div_ceil (line 45) | fn div_ceil(self, rhs: Self) -> Self { method div_ceil (line 50) | fn div_ceil(self, rhs: Self) -> Self { type StdShimsIoErrorOther (line 59) | pub trait StdShimsIoErrorOther { method other (line 60) | fn other(error: E) -> Self method other (line 67) | fn other(error: E) -> Self FILE: common/std-shims/src/sync.rs type ShimMutex (line 11) | pub struct ShimMutex(Mutex); function new (line 13) | pub const fn new(value: T) -> Self { function lock (line 17) | pub fn lock(&self) -> MutexGuard<'_, T> { FILE: common/zalloc/build.rs function main (line 2) | fn main() { function main (line 8) | fn main() { FILE: common/zalloc/src/lib.rs type ZeroizingAlloc (line 18) | pub struct ZeroizingAlloc(pub T); method allocate (line 27) | fn allocate(&self, layout: Layout) -> Result, AllocError> { method deallocate (line 31) | unsafe fn deallocate(&self, mut ptr: NonNull, layout: Layout) { method alloc (line 38) | unsafe fn alloc(&self, layout: Layout) -> *mut u8 { method dealloc (line 42) | unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { FILE: coordinator/src/cosign_evaluator.rs type CosignEvaluator (line 37) | pub struct CosignEvaluator { function update_latest_cosign (line 45) | async fn update_latest_cosign(&self) { function update_stakes (line 78) | async fn update_stakes(&self) -> Result<(), SeraiError> { function handle_new_cosign (line 107) | async fn handle_new_cosign(&self, cosign: CosignedBlock) -> Result<(), S... function new (line 269) | pub fn new(db: D, p2p: P, serai: Arc) -> mpsc::UnboundedS... FILE: coordinator/src/db.rs method active_tributaries (line 40) | pub fn active_tributaries(getter: &G) -> (Vec, Vec Vec { type TributaryEvent (line 83) | pub enum TributaryEvent { function add_tributary (line 89) | async fn add_tributary( function handle_processor_message (line 144) | async fn handle_processor_message( function handle_processor_messages (line 785) | async fn handle_processor_messages( function handle_cosigns_and_batch_publication (line 839) | async fn handle_cosigns_and_batch_publication( function handle_processors (line 971) | pub async fn handle_processors( function run (line 1015) | pub async fn run( function main (line 1316) | async fn main() { FILE: coordinator/src/p2p.rs constant MAX_LIBP2P_GOSSIP_MESSAGE_SIZE (line 50) | const MAX_LIBP2P_GOSSIP_MESSAGE_SIZE: usize = tributary::BLOCK_SIZE_LIMI... constant MAX_LIBP2P_REQRES_MESSAGE_SIZE (line 52) | const MAX_LIBP2P_REQRES_MESSAGE_SIZE: usize = constant MAX_LIBP2P_MESSAGE_SIZE (line 55) | const MAX_LIBP2P_MESSAGE_SIZE: usize = { constant LIBP2P_TOPIC (line 64) | const LIBP2P_TOPIC: &str = "serai-coordinator"; constant BLOCKS_PER_MINUTE (line 67) | const BLOCKS_PER_MINUTE: usize = (60 / (tributary::tendermint::TARGET_BL... constant BLOCKS_PER_BATCH (line 70) | const BLOCKS_PER_BATCH: usize = BLOCKS_PER_MINUTE + 1; type CosignedBlock (line 73) | pub struct CosignedBlock { type ReqResMessageKind (line 81) | pub enum ReqResMessageKind { method read (line 88) | pub fn read(reader: &mut R) -> Option { method serialize (line 107) | pub fn serialize(&self) -> Vec { type GossipMessageKind (line 125) | pub enum GossipMessageKind { method read (line 131) | pub fn read(reader: &mut R) -> Option { method serialize (line 145) | pub fn serialize(&self) -> Vec { type P2pMessageKind (line 160) | pub enum P2pMessageKind { method genesis (line 166) | fn genesis(&self) -> Option<[u8; 32]> { method from (line 179) | fn from(kind: ReqResMessageKind) -> P2pMessageKind { method from (line 185) | fn from(kind: GossipMessageKind) -> P2pMessageKind { type Message (line 191) | pub struct Message { type BlockCommit (line 198) | pub struct BlockCommit { type HeartbeatBatch (line 204) | pub struct HeartbeatBatch { type P2p (line 210) | pub trait P2p: Send + Sync + Clone + fmt::Debug + TributaryP2p { method subscribe (line 213) | async fn subscribe(&self, set: ExternalValidatorSet, genesis: [u8; 32]); method unsubscribe (line 214) | async fn unsubscribe(&self, set: ExternalValidatorSet, genesis: [u8; 3... method send_raw (line 216) | async fn send_raw(&self, to: Self::Id, msg: Vec); method broadcast_raw (line 217) | async fn broadcast_raw(&self, kind: P2pMessageKind, msg: Vec); method receive (line 218) | async fn receive(&self) -> Message; method send (line 220) | async fn send(&self, to: Self::Id, kind: ReqResMessageKind, msg: Vec, msg:... type Id (line 780) | type Id = PeerId; method subscribe (line 782) | async fn subscribe(&self, set: ExternalValidatorSet, genesis: [u8; 32]) { method unsubscribe (line 791) | async fn unsubscribe(&self, set: ExternalValidatorSet, genesis: [u8; 3... method send_raw (line 800) | async fn send_raw(&self, peer: Self::Id, msg: Vec) { method broadcast_raw (line 804) | async fn broadcast_raw(&self, kind: P2pMessageKind, msg: Vec) { method receive (line 815) | async fn receive(&self) -> Message { type RrCodec (line 249) | struct RrCodec; type Protocol (line 252) | type Protocol = &'static str; type Request (line 253) | type Request = Vec; type Response (line 254) | type Response = Vec; method read_request (line 256) | async fn read_request( method read_response (line 274) | async fn read_response( method write_request (line 281) | async fn write_request( method write_response (line 295) | async fn write_response( type Behavior (line 306) | struct Behavior { type LibP2p (line 313) | pub struct LibP2p { method fmt (line 320) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { method new (line 327) | pub fn new(serai: Arc) -> Self { method broadcast (line 822) | async fn broadcast(&self, genesis: [u8; 32], msg: Vec) { function heartbeat_tributaries_task (line 827) | pub async fn heartbeat_tributaries_task( function handle_p2p_task (line 875) | pub async fn handle_p2p_task( FILE: coordinator/src/processors.rs type Message (line 9) | pub struct Message { type Processors (line 16) | pub trait Processors: 'static + Send + Sync + Clone { method send (line 17) | async fn send(&self, network: ExternalNetworkId, msg: impl Send + Into... method recv (line 18) | async fn recv(&self, network: ExternalNetworkId) -> Message; method ack (line 19) | async fn ack(&self, msg: Message); method send (line 24) | async fn send(&self, network: ExternalNetworkId, msg: impl Send + Into... method recv (line 31) | async fn recv(&self, network: ExternalNetworkId) -> Message { method ack (line 43) | async fn ack(&self, msg: Message) { FILE: coordinator/src/substrate/cosign.rs constant COSIGN_DISTANCE (line 34) | const COSIGN_DISTANCE: u64 = 5 * 60 / 6; type HasEvents (line 37) | enum HasEvents { method set_intended_cosign (line 54) | pub fn set_intended_cosign(txn: &mut impl DbTxn, intended: u64) { method set_skipped_cosign (line 59) | pub fn set_skipped_cosign(txn: &mut impl DbTxn, skipped: u64) { method latest_cosigned_block (line 67) | pub fn latest_cosigned_block(getter: &impl Get) -> u64 { method append_cosign (line 80) | pub fn append_cosign( function block_has_events (line 90) | async fn block_has_events( function potentially_cosign_block (line 124) | async fn potentially_cosign_block( function advance_cosign_protocol_inner (line 189) | async fn advance_cosign_protocol_inner( function advance_cosign_protocol (line 321) | pub async fn advance_cosign_protocol( FILE: coordinator/src/substrate/db.rs type HandledEvent (line 18) | pub struct HandledEvent; method next_to_handle_event (line 20) | fn next_to_handle_event(getter: &impl Get, block: [u8; 32]) -> u32 { method is_unhandled (line 23) | pub fn is_unhandled(getter: &impl Get, block: [u8; 32], event_id: u32)... method handle_event (line 28) | pub fn handle_event(txn: &mut impl DbTxn, block: [u8; 32], index: u32) { FILE: coordinator/src/substrate/mod.rs function in_set (line 41) | async fn in_set( function handle_new_set (line 53) | async fn handle_new_set( function handle_batch_and_burns (line 117) | async fn handle_batch_and_burns( function handle_block (line 208) | async fn handle_block( function handle_new_blocks (line 333) | async fn handle_new_blocks( function scan_task (line 386) | pub async fn scan_task( function expected_next_batch (line 489) | pub(crate) async fn expected_next_batch( function verify_published_batches (line 517) | pub(crate) async fn verify_published_batches( FILE: coordinator/src/tests/mod.rs type MemProcessors (line 23) | pub struct MemProcessors(pub Arc MemProcessors { method send (line 33) | async fn send(&self, network: ExternalNetworkId, msg: impl Send + Into Message { method ack (line 41) | async fn ack(&self, _: Message) { type LocalP2p (line 48) | pub struct LocalP2p( method new (line 54) | pub fn new(validators: usize) -> Vec { type Id (line 66) | type Id = usize; method subscribe (line 68) | async fn subscribe(&self, _set: ExternalValidatorSet, _genesis: [u8; 32]... method unsubscribe (line 69) | async fn unsubscribe(&self, _set: ExternalValidatorSet, _genesis: [u8; 3... method send_raw (line 71) | async fn send_raw(&self, to: Self::Id, msg: Vec) { method broadcast_raw (line 77) | async fn broadcast_raw(&self, kind: P2pMessageKind, msg: Vec) { method receive (line 104) | async fn receive(&self) -> P2pMessage { method broadcast (line 117) | async fn broadcast(&self, genesis: [u8; 32], msg: Vec) { FILE: coordinator/src/tests/tributary/chain.rs function new_keys (line 35) | pub fn new_keys( function new_spec (line 45) | pub fn new_spec( function new_tributaries (line 71) | pub async fn new_tributaries( function run_tributaries (line 97) | pub async fn run_tributaries( function wait_for_tx_inclusion (line 119) | pub async fn wait_for_tx_inclusion( function tributary_test (line 159) | async fn tributary_test() { FILE: coordinator/src/tests/tributary/dkg.rs function dkg_test (line 40) | async fn dkg_test() { FILE: coordinator/src/tests/tributary/handle_p2p.rs function handle_p2p_test (line 26) | async fn handle_p2p_test() { FILE: coordinator/src/tests/tributary/mod.rs method publish_set_keys (line 32) | async fn publish_set_keys( function random_u32 (line 44) | fn random_u32(rng: &mut R) -> u32 { function random_vec (line 48) | fn random_vec(rng: &mut R, limit: usize) -> Vec { function random_sign_data (line 55) | fn random_sign_data(value: &RW) { function tx_size_limit (line 82) | fn tx_size_limit() { function serialize_sign_data (line 108) | fn serialize_sign_data() { function serialize_transaction (line 146) | fn serialize_transaction() { FILE: coordinator/src/tests/tributary/sync.rs function sync_test (line 29) | async fn sync_test() { FILE: coordinator/src/tests/tributary/tx.rs function tx_test (line 22) | async fn tx_test() { FILE: coordinator/src/tributary/db.rs type Topic (line 21) | pub enum Topic { type DataSpecification (line 30) | pub struct DataSpecification { type DataSet (line 36) | pub enum DataSet { type Accumulation (line 41) | pub enum Accumulation { method get_as_keys (line 89) | pub fn get_as_keys(getter: &impl Get, genesis: [u8; 32]) -> Vec< Op... method schedule_reattempt (line 142) | pub fn schedule_reattempt( method take (line 176) | pub fn take(txn: &mut impl DbTxn, genesis: [u8; 32], block_number: u32) ... method take_signed_transaction (line 186) | pub fn take_signed_transaction( FILE: coordinator/src/tributary/handle.rs function dkg_confirmation_nonces (line 36) | pub fn dkg_confirmation_nonces( function generated_key_pair (line 47) | pub fn generated_key_pair( function unflatten (line 62) | fn unflatten( function accumulate (line 90) | fn accumulate( function handle_data (line 169) | fn handle_data( function check_sign_data_len (line 220) | fn check_sign_data_len( function handle_application_tx (line 244) | pub(crate) async fn handle_application_tx(&mut self, tx: Transaction) { FILE: coordinator/src/tributary/mod.rs function removed_as_of_dkg_attempt (line 28) | pub fn removed_as_of_dkg_attempt( function removed_as_of_set_keys (line 42) | pub fn removed_as_of_set_keys( function publish_signed_transaction (line 61) | pub async fn publish_signed_transaction( FILE: coordinator/src/tributary/scanner.rs type RecognizedIdType (line 33) | pub enum RecognizedIdType { type RIDTrait (line 39) | pub trait RIDTrait { method recognized_id (line 40) | async fn recognized_id( method recognized_id (line 54) | async fn recognized_id( type PublishSeraiTransaction (line 66) | pub trait PublishSeraiTransaction { method publish_set_keys (line 67) | async fn publish_set_keys( method publish_set_keys (line 129) | async fn publish_set_keys( type PTTTrait (line 160) | pub trait PTTTrait { method publish_tributary_tx (line 161) | async fn publish_tributary_tx(&self, tx: Transaction); method publish_tributary_tx (line 165) | async fn publish_tributary_tx(&self, tx: Transaction) { type TributaryBlockHandler (line 170) | pub struct TributaryBlockHandler< function fatal_slash (line 203) | pub fn fatal_slash(&mut self, slashing: [u8; 32], reason: &str) { function handle (line 216) | async fn handle(mut self) { function handle_new_blocks (line 661) | pub(crate) async fn handle_new_blocks< function scan_tributaries_task (line 722) | pub(crate) async fn scan_tributaries_task< FILE: coordinator/src/tributary/signing_protocol.rs type SigningProtocol (line 92) | struct SigningProtocol<'a, T: DbTxn, C: Encode> { function preprocess_internal (line 100) | fn preprocess_internal( function share_internal (line 150) | fn share_internal( function complete_internal (line 183) | fn complete_internal( function threshold_i_map_to_keys_and_musig_i_map (line 208) | fn threshold_i_map_to_keys_and_musig_i_map( type DkgConfirmerSigningProtocol (line 252) | type DkgConfirmerSigningProtocol<'a, T> = SigningProtocol<'a, T, (&'stat... type DkgConfirmer (line 254) | pub(crate) struct DkgConfirmer<'a, T: DbTxn> { function new (line 263) | pub(crate) fn new<'a>( function signing_protocol (line 274) | fn signing_protocol(&mut self) -> DkgConfirmerSigningProtocol<'_, T> { function preprocess_internal (line 279) | fn preprocess_internal(&mut self) -> (AlgorithmSignMachine [u8; 64] { function share_internal (line 288) | fn share_internal( function share (line 304) | pub(crate) fn share( function complete (line 312) | pub(crate) fn complete( FILE: coordinator/src/tributary/spec.rs function borsh_serialize_validators (line 15) | fn borsh_serialize_validators( function borsh_deserialize_validators (line 28) | fn borsh_deserialize_validators( type TributarySpec (line 44) | pub struct TributarySpec { method new (line 56) | pub fn new( method set (line 72) | pub fn set(&self) -> ExternalValidatorSet { method genesis (line 76) | pub fn genesis(&self) -> [u8; 32] { method start_time (line 88) | pub fn start_time(&self) -> u64 { method n (line 92) | pub fn n(&self, removed_validators: &[::G]) ... method t (line 100) | pub fn t(&self) -> u16 { method i (line 105) | pub fn i( method reverse_lookup_i (line 141) | pub fn reverse_lookup_i( method validators (line 154) | pub fn validators(&self) -> Vec<(::G, u64)> { FILE: coordinator/src/tributary/transaction.rs type Label (line 27) | pub enum Label { method nonce (line 34) | pub fn nonce(&self) -> u32 { type SignData (line 43) | pub struct SignData { method fmt (line 54) | fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> Result<(), core::fm... function read (line 66) | pub(crate) fn read(reader: &mut R) -> io::Result { function write (line 104) | pub(crate) fn write(&self, writer: &mut W) -> io::Result<(... type Transaction (line 133) | pub enum Transaction { method empty_signed (line 628) | pub fn empty_signed() -> Signed { method sign (line 640) | pub fn sign( method sign_completed_challenge (line 703) | pub fn sign_completed_challenge(&self) -> ::F { method fmt (line 199) | fn fmt(&self, fmt: &mut core::fmt::Formatter<'_>) -> Result<(), core::fm... method read (line 260) | fn read(reader: &mut R) -> io::Result { method write (line 447) | fn write(&self, writer: &mut W) -> io::Result<()> { method kind (line 572) | fn kind(&self) -> TransactionKind<'_> { method hash (line 604) | fn hash(&self) -> [u8; 32] { method verify (line 613) | fn verify(&self) -> Result<(), TransactionError> { FILE: coordinator/tributary/src/block.rs type BlockError (line 22) | pub enum BlockError { type BlockHeader (line 53) | pub struct BlockHeader { method hash (line 73) | pub fn hash(&self) -> [u8; 32] { method read (line 59) | fn read(reader: &mut R) -> io::Result { method write (line 66) | fn write(&self, writer: &mut W) -> io::Result<()> { type Block (line 79) | pub struct Block { method read (line 85) | fn read(reader: &mut R) -> io::Result { method write (line 100) | fn write(&self, writer: &mut W) -> io::Result<()> { function new (line 114) | pub(crate) fn new(parent: [u8; 32], provided: Vec, mempool: Vec [u8; 32] { function hash (line 166) | pub fn hash(&self) -> [u8; 32] { function verify (line 171) | pub(crate) fn verify( FILE: coordinator/tributary/src/blockchain.rs type Blockchain (line 18) | pub(crate) struct Blockchain { function tip_key (line 33) | fn tip_key(genesis: [u8; 32]) -> Vec { function block_number_key (line 36) | fn block_number_key(&self) -> Vec { function block_key (line 39) | fn block_key(genesis: &[u8], hash: &[u8; 32]) -> Vec { function block_hash_key (line 42) | fn block_hash_key(genesis: &[u8], block_number: u64) -> Vec { function commit_key (line 45) | fn commit_key(genesis: &[u8], hash: &[u8; 32]) -> Vec { function block_after_key (line 48) | fn block_after_key(genesis: &[u8], hash: &[u8; 32]) -> Vec { function unsigned_included_key (line 51) | fn unsigned_included_key(genesis: &[u8], hash: &[u8; 32]) -> Vec { function provided_included_key (line 54) | fn provided_included_key(genesis: &[u8], hash: &[u8; 32]) -> Vec { function next_nonce_key (line 57) | fn next_nonce_key( function new (line 69) | pub(crate) fn new( function tip (line 99) | pub(crate) fn tip(&self) -> [u8; 32] { function block_number (line 103) | pub(crate) fn block_number(&self) -> u64 { function block_from_db (line 107) | pub(crate) fn block_from_db(db: &D, genesis: [u8; 32], block: &[u8; 32])... function commit_from_db (line 112) | pub(crate) fn commit_from_db(db: &D, genesis: [u8; 32], block: &[u8; 32]... function block_hash_from_db (line 116) | pub(crate) fn block_hash_from_db(db: &D, genesis: [u8; 32], block: u64) ... function commit (line 120) | pub(crate) fn commit(&self, block: &[u8; 32]) -> Option> { function block_hash (line 124) | pub(crate) fn block_hash(&self, block: u64) -> Option<[u8; 32]> { function commit_by_block_number (line 128) | pub(crate) fn commit_by_block_number(&self, block: u64) -> Option [u8; 32] { function add_transaction (line 155) | pub(crate) fn add_transaction( function provide_transaction (line 193) | pub(crate) fn provide_transaction(&mut self, tx: T) -> Result<(), Provid... function next_nonce (line 197) | pub(crate) fn next_nonce( function build_block (line 219) | pub(crate) fn build_block(&mut self, schema: &N::SignatureSc... function verify_block (line 230) | pub(crate) fn verify_block( function add_block (line 276) | pub(crate) fn add_block( FILE: coordinator/tributary/src/lib.rs constant TRANSACTION_SIZE_LIMIT (line 54) | pub const TRANSACTION_SIZE_LIMIT: usize = 3_000_000; constant ACCOUNT_MEMPOOL_LIMIT (line 56) | pub const ACCOUNT_MEMPOOL_LIMIT: u32 = 50; constant BLOCK_SIZE_LIMIT (line 60) | pub const BLOCK_SIZE_LIMIT: usize = 3_001_000; constant TENDERMINT_MESSAGE (line 62) | pub(crate) const TENDERMINT_MESSAGE: u8 = 0; constant TRANSACTION_MESSAGE (line 63) | pub(crate) const TRANSACTION_MESSAGE: u8 = 1; type Transaction (line 67) | pub enum Transaction { function hash (line 103) | pub fn hash(&self) -> [u8; 32] { function kind (line 110) | pub fn kind(&self) -> TransactionKind<'_> { type ReadWrite (line 119) | pub trait ReadWrite: Sized { method read (line 73) | fn read(reader: &mut R) -> io::Result { method write (line 88) | fn write(&self, writer: &mut W) -> io::Result<()> { method read (line 120) | fn read(reader: &mut R) -> io::Result; method write (line 121) | fn write(&self, writer: &mut W) -> io::Result<()>; method serialize (line 123) | fn serialize(&self) -> Vec { type P2p (line 132) | pub trait P2p: 'static + Send + Sync + Clone + Debug { method broadcast (line 138) | async fn broadcast(&self, genesis: [u8; 32], msg: Vec); method broadcast (line 143) | async fn broadcast(&self, genesis: [u8; 32], msg: Vec) { type Tributary (line 149) | pub struct Tributary { function new (line 161) | pub async fn new( function block_time (line 213) | pub fn block_time() -> u32 { function genesis (line 217) | pub fn genesis(&self) -> [u8; 32] { function block_number (line 221) | pub async fn block_number(&self) -> u64 { function tip (line 224) | pub async fn tip(&self) -> [u8; 32] { function reader (line 228) | pub fn reader(&self) -> TributaryReader { function provide_transaction (line 232) | pub async fn provide_transaction(&self, tx: T) -> Result<(), ProvidedErr... function next_nonce (line 236) | pub async fn next_nonce( function add_transaction (line 247) | pub async fn add_transaction(&self, tx: T) -> Result, commit: Vec) -> bool { function handle_message (line 308) | pub async fn handle_message(&self, msg: &[u8]) -> bool { function next_block_notification (line 345) | pub async fn next_block_notification( type TributaryReader (line 355) | pub struct TributaryReader(D, [u8; 32], Phan... function genesis (line 357) | pub fn genesis(&self) -> [u8; 32] { function block (line 363) | pub fn block(&self, hash: &[u8; 32]) -> Option> { function commit (line 366) | pub fn commit(&self, hash: &[u8; 32]) -> Option> { function parsed_commit (line 369) | pub fn parsed_commit(&self, hash: &[u8; 32]) -> Option Option<[u8; 32]> { function time_of_block (line 375) | pub fn time_of_block(&self, hash: &[u8; 32]) -> Option { function locally_provided_txs_in_block (line 381) | pub fn locally_provided_txs_in_block(&self, hash: &[u8; 32], order: &str... function tip (line 386) | pub fn tip(&self) -> [u8; 32] { FILE: coordinator/tributary/src/mempool.rs type Mempool (line 20) | pub(crate) struct Mempool { function transaction_key (line 30) | fn transaction_key(&self, hash: &[u8]) -> Vec { function current_mempool_key (line 33) | fn current_mempool_key(&self) -> Vec { function save_tx (line 38) | fn save_tx(&mut self, tx: Transaction) { function unsigned_already_exist (line 53) | fn unsigned_already_exist( function new (line 61) | pub(crate) fn new(db: D, genesis: [u8; 32]) -> Self { function add (line 108) | pub(crate) fn add< function next_nonce_in_mempool (line 180) | pub(crate) fn next_nonce_in_mempool( function block (line 189) | pub(crate) fn block(&mut self) -> Vec> { function remove (line 222) | pub(crate) fn remove(&mut self, tx: &[u8; 32]) { function txs (line 257) | pub(crate) fn txs(&self) -> &HashMap<[u8; 32], Transaction> { FILE: coordinator/tributary/src/merkle.rs function merkle (line 3) | pub(crate) fn merkle(hash_args: &[[u8; 32]]) -> [u8; 32] { FILE: coordinator/tributary/src/provided.rs type ProvidedError (line 10) | pub enum ProvidedError { type ProvidedTransactions (line 26) | pub struct ProvidedTransactions { function transaction_key (line 34) | fn transaction_key(&self, hash: &[u8]) -> Vec { function current_provided_key (line 37) | fn current_provided_key(&self) -> Vec { function locally_provided_quantity_key (line 40) | pub(crate) fn locally_provided_quantity_key(genesis: &[u8; 32], order: &... function on_chain_provided_quantity_key (line 43) | pub(crate) fn on_chain_provided_quantity_key(genesis: &[u8; 32], order: ... function block_provided_quantity_key (line 46) | pub(crate) fn block_provided_quantity_key( function on_chain_provided_key (line 54) | pub(crate) fn on_chain_provided_key(genesis: &[u8; 32], order: &str, id:... function new (line 62) | pub(crate) fn new(db: D, genesis: [u8; 32]) -> Self { function provide (line 89) | pub(crate) fn provide(&mut self, tx: T) -> Result<(), ProvidedError> { function complete (line 148) | pub(crate) fn complete( FILE: coordinator/tributary/src/tendermint/mod.rs constant DST (line 49) | const DST: &[u8] = b"Tributary Tendermint Commit Aggregator"; function challenge (line 51) | fn challenge( type Signer (line 67) | pub struct Signer { method new (line 73) | pub(crate) fn new(genesis: [u8; 32], key: Zeroizing< Option { method sign (line 89) | async fn sign(&self, msg: &[u8]) -> Self::Signature { type Validators (line 126) | pub struct Validators { method new (line 134) | pub(crate) fn new( type ValidatorId (line 162) | type ValidatorId = [u8; 32]; type Signature (line 163) | type Signature = [u8; 64]; type AggregateSignature (line 164) | type AggregateSignature = Vec; type Signer (line 165) | type Signer = Arc; method verify (line 168) | fn verify(&self, validator: Self::ValidatorId, msg: &[u8], sig: &Self::S... method aggregate (line 181) | fn aggregate( method verify_aggregate (line 201) | fn verify_aggregate( type ValidatorId (line 233) | type ValidatorId = [u8; 32]; method total_weight (line 235) | fn total_weight(&self) -> u64 { method weight (line 238) | fn weight(&self, validator: Self::ValidatorId) -> u64 { method proposer (line 241) | fn proposer(&self, block: BlockNumber, round: RoundNumber) -> Self::Vali... type TendermintBlock (line 255) | pub struct TendermintBlock(pub Vec); type Id (line 257) | type Id = [u8; 32]; method id (line 258) | fn id(&self) -> Self::Id { type TendermintNetwork (line 264) | pub struct TendermintNetwork { constant BLOCK_PROCESSING_TIME (line 274) | pub const BLOCK_PROCESSING_TIME: u32 = 999; constant LATENCY_TIME (line 275) | pub const LATENCY_TIME: u32 = 1667; constant TARGET_BLOCK_TIME (line 276) | pub const TARGET_BLOCK_TIME: u32 = BLOCK_PROCESSING_TIME + (3 * LATENCY_... type Db (line 280) | type Db = D; type ValidatorId (line 282) | type ValidatorId = [u8; 32]; type SignatureScheme (line 283) | type SignatureScheme = Arc; type Weights (line 284) | type Weights = Arc; type Block (line 285) | type Block = TendermintBlock; constant BLOCK_PROCESSING_TIME (line 291) | const BLOCK_PROCESSING_TIME: u32 = BLOCK_PROCESSING_TIME; constant LATENCY_TIME (line 292) | const LATENCY_TIME: u32 = LATENCY_TIME; method signer (line 294) | fn signer(&self) -> Arc { method signature_scheme (line 297) | fn signature_scheme(&self) -> Arc { method weights (line 300) | fn weights(&self) -> Arc { method broadcast (line 304) | async fn broadcast(&mut self, msg: SignedMessageFor) { method slash (line 310) | async fn slash(&mut self, validator: Self::ValidatorId, slash_event: Sla... method validate (line 345) | async fn validate(&self, block: &Self::Block) -> Result<(), TendermintBl... method add_block (line 362) | async fn add_block( FILE: coordinator/tributary/src/tendermint/tx.rs type TendermintTx (line 24) | pub enum TendermintTx { method read (line 29) | fn read(reader: &mut R) -> io::Result { method write (line 35) | fn write(&self, writer: &mut W) -> io::Result<()> { method kind (line 43) | fn kind(&self) -> TransactionKind<'_> { method hash (line 49) | fn hash(&self) -> [u8; 32] { method sig_hash (line 53) | fn sig_hash(&self, _genesis: [u8; 32]) -> ::F { method verify (line 59) | fn verify(&self) -> Result<(), TransactionError> { function verify_tendermint_tx (line 64) | pub(crate) fn verify_tendermint_tx( FILE: coordinator/tributary/src/tests/block.rs type N (line 22) | type N = TendermintNetwork; type NonceTransaction (line 27) | struct NonceTransaction(u32, u8, Signed); method new (line 30) | fn new(nonce: u32, distinguisher: u8) -> Self { method read (line 47) | fn read(reader: &mut R) -> io::Result { method write (line 58) | fn write(&self, writer: &mut W) -> io::Result<()> { method kind (line 65) | fn kind(&self) -> TransactionKind<'_> { method hash (line 69) | fn hash(&self) -> [u8; 32] { method verify (line 73) | fn verify(&self) -> Result<(), TransactionError> { function empty_block (line 79) | fn empty_block() { function duplicate_nonces (line 102) | fn duplicate_nonces() { FILE: coordinator/tributary/src/tests/blockchain.rs type N (line 30) | type N = TendermintNetwork; function new_blockchain (line 32) | fn new_blockchain( function block_addition (line 44) | fn block_addition() { function invalid_block (line 63) | fn invalid_block() { function signed_transaction (line 150) | fn signed_transaction() { function provided_transaction (line 206) | fn provided_transaction() { function tendermint_evidence_tx (line 340) | async fn tendermint_evidence_tx() { function block_tx_ordering (line 397) | async fn block_tx_ordering() { FILE: coordinator/tributary/src/tests/mempool.rs type N (line 20) | type N = TendermintNetwork; function new_mempool (line 22) | fn new_mempool() -> ([u8; 32], MemDb, Mempool) { FILE: coordinator/tributary/src/tests/tendermint.rs function assert_target_block_time (line 8) | fn assert_target_block_time() { FILE: coordinator/tributary/src/tests/transaction/mod.rs function random_signed (line 35) | pub fn random_signed(rng: &mut R) -> Signed { function random_signed_with_nonce (line 46) | pub fn random_signed_with_nonce(rng: &mut R, non... type ProvidedTransaction (line 53) | pub struct ProvidedTransaction(pub Vec); method read (line 56) | fn read(reader: &mut R) -> io::Result { method write (line 64) | fn write(&self, writer: &mut W) -> io::Result<()> { method kind (line 71) | fn kind(&self) -> TransactionKind<'_> { method hash (line 79) | fn hash(&self) -> [u8; 32] { method verify (line 83) | fn verify(&self) -> Result<(), TransactionError> { function random_provided_transaction (line 88) | pub fn random_provided_transaction( type SignedTransaction (line 103) | pub struct SignedTransaction(pub Vec, pub Signed); method read (line 106) | fn read(reader: &mut R) -> io::Result { method write (line 115) | fn write(&self, writer: &mut W) -> io::Result<()> { method kind (line 123) | fn kind(&self) -> TransactionKind<'_> { method hash (line 127) | fn hash(&self) -> [u8; 32] { method verify (line 132) | fn verify(&self) -> Result<(), TransactionError> { function signed_transaction (line 137) | pub fn signed_transaction( function random_signed_transaction (line 160) | pub fn random_signed_transaction( function new_genesis (line 173) | pub fn new_genesis() -> [u8; 32] { function tendermint_meta (line 179) | pub async fn tendermint_meta() -> ([u8; 32], Signer, [u8; 32], Arc( function random_evidence_tx (line 211) | pub async fn random_evidence_tx( FILE: coordinator/tributary/src/tests/transaction/signed.rs function serialize_signed (line 15) | fn serialize_signed() { function sig_hash (line 21) | fn sig_hash() { function signed_transaction (line 31) | fn signed_transaction() { function invalid_nonce (line 81) | fn invalid_nonce() { FILE: coordinator/tributary/src/tests/transaction/tendermint.rs type N (line 31) | type N = TendermintNetwork; function serialize_tendermint (line 34) | async fn serialize_tendermint() { function invalid_valid_round (line 43) | async fn invalid_valid_round() { function invalid_precommit_signature (line 80) | async fn invalid_precommit_signature() { function evidence_with_prevote (line 129) | async fn evidence_with_prevote() { function conflicting_msgs_evidence_tx (line 174) | async fn conflicting_msgs_evidence_tx() { FILE: coordinator/tributary/src/transaction.rs type TransactionError (line 19) | pub enum TransactionError { type Signed (line 45) | pub struct Signed { method read_without_nonce (line 86) | pub fn read_without_nonce(reader: &mut R, nonce: u32) -> ... method write_without_nonce (line 101) | pub fn write_without_nonce(&self, writer: &mut W) -> io:... method read (line 52) | fn read(reader: &mut R) -> io::Result { method write (line 74) | fn write(&self, writer: &mut W) -> io::Result<()> { type TransactionKind (line 113) | pub enum TransactionKind<'a> { type Transaction (line 146) | pub trait Transaction: 'static + Send + Sync + Clone + Eq + Debug + Read... method kind (line 148) | fn kind(&self) -> TransactionKind<'_>; method hash (line 153) | fn hash(&self) -> [u8; 32]; method verify (line 156) | fn verify(&self) -> Result<(), TransactionError>; method sig_hash (line 163) | fn sig_hash(&self, genesis: [u8; 32]) -> ::F { type GAIN (line 185) | pub trait GAIN: FnMut(&::G, &[u8]) -> Option( FILE: coordinator/tributary/tendermint/src/block.rs type BlockData (line 16) | pub(crate) struct BlockData { function new (line 39) | pub(crate) fn new( function round (line 67) | pub(crate) fn round(&self) -> &RoundData { function round_mut (line 71) | pub(crate) fn round_mut(&mut self) -> &mut RoundData { function populate_end_time (line 78) | pub(crate) fn populate_end_time(&mut self, round: RoundNumber) { function new_round (line 92) | pub(crate) fn new_round( function message (line 128) | pub(crate) fn message(&mut self, data: DataFor) -> Option Option; method sign (line 47) | async fn sign(&self, msg: &[u8]) -> Self::Signature; type ValidatorId (line 52) | type ValidatorId = S::ValidatorId; type Signature (line 53) | type Signature = S::Signature; method validator_id (line 55) | async fn validator_id(&self) -> Option { method sign (line 59) | async fn sign(&self, msg: &[u8]) -> Self::Signature { type SignatureScheme (line 65) | pub trait SignatureScheme: Send + Sync + Clone { method verify (line 81) | fn verify(&self, validator: Self::ValidatorId, msg: &[u8], sig: &Self:... method aggregate (line 85) | fn aggregate( method verify_aggregate (line 93) | fn verify_aggregate( type ValidatorId (line 102) | type ValidatorId = S::ValidatorId; type Signature (line 103) | type Signature = S::Signature; type AggregateSignature (line 104) | type AggregateSignature = S::AggregateSignature; type Signer (line 105) | type Signer = S::Signer; method verify (line 107) | fn verify(&self, validator: Self::ValidatorId, msg: &[u8], sig: &Self:... method aggregate (line 111) | fn aggregate( method verify_aggregate (line 121) | fn verify_aggregate( type Commit (line 135) | pub struct Commit { method clone (line 145) | fn clone(&self) -> Self { type Weights (line 155) | pub trait Weights: Send + Sync { method total_weight (line 159) | fn total_weight(&self) -> u64; method weight (line 161) | fn weight(&self, validator: Self::ValidatorId) -> u64; method threshold (line 163) | fn threshold(&self) -> u64 { method fault_threshold (line 167) | fn fault_threshold(&self) -> u64 { method proposer (line 172) | fn proposer(&self, block: BlockNumber, round: RoundNumber) -> Self::Va... type ValidatorId (line 176) | type ValidatorId = W::ValidatorId; method total_weight (line 178) | fn total_weight(&self) -> u64 { method weight (line 182) | fn weight(&self, validator: Self::ValidatorId) -> u64 { method proposer (line 186) | fn proposer(&self, block: BlockNumber, round: RoundNumber) -> Self::Va... type BlockError (line 193) | pub enum BlockError { type Block (line 204) | pub trait Block: Send + Sync + Clone + PartialEq + Eq + Debug + Encode +... method id (line 209) | fn id(&self) -> Self::Id; type Network (line 214) | pub trait Network: Sized + Send + Sync { constant BLOCK_PROCESSING_TIME (line 232) | const BLOCK_PROCESSING_TIME: u32; constant LATENCY_TIME (line 236) | const LATENCY_TIME: u32; method block_time (line 239) | fn block_time() -> u32 { method signer (line 247) | fn signer(&self) -> ::Signer; method signature_scheme (line 249) | fn signature_scheme(&self) -> Self::SignatureScheme; method weights (line 251) | fn weights(&self) -> Self::Weights; method verify_commit (line 256) | fn verify_commit( method broadcast (line 283) | async fn broadcast(&mut self, msg: SignedMessageFor); method slash (line 288) | async fn slash(&mut self, validator: Self::ValidatorId, slash_event: S... method validate (line 291) | async fn validate(&self, block: &Self::Block) -> Result<(), BlockError>; method add_block (line 301) | async fn add_block( FILE: coordinator/tributary/tendermint/src/lib.rs constant MESSAGE_TAPE_KEY (line 37) | const MESSAGE_TAPE_KEY: &[u8] = b"tendermint-machine-message_tape"; function message_tape_key (line 38) | fn message_tape_key(genesis: [u8; 32]) -> Vec { function commit_msg (line 42) | pub fn commit_msg(end_time: u64, id: &[u8]) -> Vec { type Step (line 47) | pub enum Step { type Data (line 54) | pub enum Data { method eq (line 61) | fn eq(&self, other: &Data) -> bool { function hash (line 75) | fn hash(&self, state: &mut H) { function step (line 86) | pub fn step(&self) -> Step { type Message (line 96) | pub struct Message { type SignedMessage (line 106) | pub struct SignedMessage { function block (line 113) | pub fn block(&self) -> BlockNumber { function verify_signature (line 118) | pub fn verify_signature = type MessageFor (line 151) | pub(crate) type MessageFor = Message< type SignedMessageFor (line 157) | pub type SignedMessageFor = SignedMessage< function decode_signed_message (line 163) | pub fn decode_signed_message(mut data: &[u8]) -> Option( function verify_tendermint_evidence (line 181) | pub fn verify_tendermint_evidence( type SlashEvent (line 248) | pub enum SlashEvent { type Upons (line 256) | struct Upons { type TendermintMachine (line 264) | pub struct TendermintMachine { type SyncedBlock (line 285) | pub struct SyncedBlock { type SyncedBlockSender (line 291) | pub type SyncedBlockSender = mpsc::UnboundedSender>; type SyncedBlockResultReceiver (line 292) | pub type SyncedBlockResultReceiver = mpsc::UnboundedReceiver; type MessageSender (line 294) | pub type MessageSender = mpsc::UnboundedSender>; type TendermintHandle (line 297) | pub struct TendermintHandle { function broadcast (line 314) | fn broadcast(&mut self, data: DataFor) { function round (line 324) | fn round(&mut self, round: RoundNumber, time: Option) ... function reset (line 350) | async fn reset(&mut self, end_round: RoundNumber, proposal: Option Option<(Option bo... function all_any_round_upons (line 649) | async fn all_any_round_upons(&mut self, round: RoundNumber) -> bool { function verify_precommit_signature (line 657) | async fn verify_precommit_signature( function message (line 686) | async fn message(&mut self, signed: &SignedMessageFor) -> Result<(), ... function new (line 850) | pub async fn new( function run (line 937) | pub async fn run(mut self) { FILE: coordinator/tributary/tendermint/src/message_log.rs type RoundLog (line 7) | type RoundLog = HashMap<::ValidatorId, HashMap { function new (line 17) | pub(crate) fn new(weights: Arc) -> MessageLog { function log (line 28) | pub(crate) fn log(&mut self, signed: SignedMessageFor) -> Result u64 { function has_participation (line 66) | pub(crate) fn has_participation(&self, round: RoundNumber, step: Step) -... function has_consensus (line 71) | pub(crate) fn has_consensus(&self, round: RoundNumber, data: &DataFor... FILE: coordinator/tributary/tendermint/src/round.rs type RoundData (line 16) | pub struct RoundData { function new (line 25) | pub fn new(number: RoundNumber, start_time: CanonicalInstant) -> Self { function timeout (line 35) | fn timeout(&self, step: Step) -> CanonicalInstant { function end_time (line 49) | pub fn end_time(&self) -> CanonicalInstant { function set_timeout (line 53) | pub(crate) fn set_timeout(&mut self, step: Step) { function timeout_future (line 59) | pub(crate) async fn timeout_future(&self) -> Step { FILE: coordinator/tributary/tendermint/src/time.rs type CanonicalInstant (line 5) | pub struct CanonicalInstant { method new (line 17) | pub fn new(time: u64) -> CanonicalInstant { method canonical (line 30) | pub fn canonical(&self) -> u64 { method instant (line 34) | pub fn instant(&self) -> Instant { type Output (line 40) | type Output = CanonicalInstant; method add (line 41) | fn add(self, duration: Duration) -> CanonicalInstant { function sys_time (line 12) | pub(crate) fn sys_time(time: u64) -> SystemTime { FILE: coordinator/tributary/tendermint/tests/ext.rs type TestValidatorId (line 20) | type TestValidatorId = u16; type TestBlockId (line 21) | type TestBlockId = [u8; 4]; type TestSigner (line 23) | struct TestSigner(u16); type ValidatorId (line 26) | type ValidatorId = TestValidatorId; type Signature (line 27) | type Signature = [u8; 32]; method validator_id (line 29) | async fn validator_id(&self) -> Option { method sign (line 33) | async fn sign(&self, msg: &[u8]) -> [u8; 32] { type TestSignatureScheme (line 42) | struct TestSignatureScheme; type ValidatorId (line 44) | type ValidatorId = TestValidatorId; type Signature (line 45) | type Signature = [u8; 32]; type AggregateSignature (line 46) | type AggregateSignature = Vec<[u8; 32]>; type Signer (line 47) | type Signer = TestSigner; method verify (line 50) | fn verify(&self, validator: u16, msg: &[u8], sig: &[u8; 32]) -> bool { method aggregate (line 54) | fn aggregate( method verify_aggregate (line 64) | fn verify_aggregate( type TestWeights (line 78) | struct TestWeights; type ValidatorId (line 80) | type ValidatorId = TestValidatorId; method total_weight (line 82) | fn total_weight(&self) -> u64 { method weight (line 85) | fn weight(&self, id: TestValidatorId) -> u64 { method proposer (line 89) | fn proposer(&self, number: BlockNumber, round: RoundNumber) -> TestValid... type TestBlock (line 95) | struct TestBlock { type Id (line 101) | type Id = TestBlockId; method id (line 103) | fn id(&self) -> TestBlockId { type TestNetwork (line 109) | struct TestNetwork( method new (line 165) | async fn new( type Db (line 116) | type Db = MemDb; type ValidatorId (line 118) | type ValidatorId = TestValidatorId; type SignatureScheme (line 119) | type SignatureScheme = TestSignatureScheme; type Weights (line 120) | type Weights = TestWeights; type Block (line 121) | type Block = TestBlock; constant BLOCK_PROCESSING_TIME (line 123) | const BLOCK_PROCESSING_TIME: u32 = 2000; constant LATENCY_TIME (line 124) | const LATENCY_TIME: u32 = 1000; method signer (line 126) | fn signer(&self) -> TestSigner { method signature_scheme (line 130) | fn signature_scheme(&self) -> TestSignatureScheme { method weights (line 134) | fn weights(&self) -> TestWeights { method broadcast (line 138) | async fn broadcast(&mut self, msg: SignedMessageFor) { method slash (line 144) | async fn slash(&mut self, id: TestValidatorId, event: SlashEvent) { method validate (line 148) | async fn validate(&self, block: &TestBlock) -> Result<(), BlockError> { method add_block (line 152) | async fn add_block( function test_machine (line 194) | async fn test_machine() { function test_machine_with_historic_start_time (line 200) | async fn test_machine_with_historic_start_time() { FILE: crypto/ciphersuite/kp256/src/lib.rs function test_oversize_dst (line 97) | fn test_oversize_dst() { type Secp256k1 (line 112) | pub struct Secp256k1; function test_secp256k1 (line 115) | fn test_secp256k1() { type P256 (line 147) | pub struct P256; function test_p256 (line 150) | fn test_p256() { FILE: crypto/ciphersuite/src/lib.rs type Ciphersuite (line 30) | pub trait Ciphersuite: constant ID (line 43) | const ID: &'static [u8]; method generator (line 47) | fn generator() -> Self::G; method hash_to_F (line 58) | fn hash_to_F(dst: &[u8], msg: &[u8]) -> Self::F; method random_nonzero_F (line 62) | fn random_nonzero_F(rng: &mut R) -> Self::F { method read_F (line 74) | fn read_F(reader: &mut R) -> io::Result { method read_G (line 91) | fn read_G(reader: &mut R) -> io::Result { FILE: crypto/dalek-ff-group/src/ciphersuite.rs type Ristretto (line 44) | pub struct Ristretto; function test_ristretto (line 47) | fn test_ristretto() { type Ed25519 (line 72) | pub struct Ed25519; function test_ed25519 (line 75) | fn test_ed25519() { FILE: crypto/dalek-ff-group/src/field.rs constant MODULUS (line 26) | const MODULUS: U256 = U256::from_u8(1).shl_vartime(255).saturating_sub(&... constant WIDE_MODULUS (line 27) | const WIDE_MODULUS: U512 = U256::ZERO.concat(&MODULUS); type ResidueType (line 35) | type ResidueType = Residue; type FieldElement (line 40) | pub struct FieldElement(ResidueType); method from_u256 (line 223) | pub const fn from_u256(u256: &U256) -> Self { method wide_reduce (line 230) | pub fn wide_reduce(value: [u8; 64]) -> Self { method pow (line 235) | pub fn pow(&self, other: FieldElement) -> FieldElement { method sqrt_ratio_i (line 278) | pub fn sqrt_ratio_i(u: FieldElement, v: FieldElement) -> (Choice, Fiel... method from_uniform_bytes (line 310) | fn from_uniform_bytes(bytes: &[u8; 64]) -> Self { method sum (line 316) | fn sum>(iter: I) -> FieldElement { method sum (line 326) | fn sum>(iter: I) -> FieldElement { method product (line 332) | fn product>(iter: I) -> FieldElement { method product (line 342) | fn product>(iter: I) -> FieldElem... constant SQRT_M1 (line 45) | const SQRT_M1: FieldElement = FieldElement( constant MOD_3_8 (line 51) | const MOD_3_8: FieldElement = FieldElement(ResidueType::new( constant MOD_5_8 (line 56) | const MOD_5_8: FieldElement = FieldElement(ResidueType::sub(&MOD_3_8.0, ... function reduce (line 58) | fn reduce(x: U512) -> ResidueType { type Output (line 90) | type Output = Self; method neg (line 91) | fn neg(self) -> Self::Output { type Output (line 97) | type Output = FieldElement; method neg (line 98) | fn neg(self) -> Self::Output { constant ZERO (line 104) | const ZERO: Self = Self(ResidueType::ZERO); constant ONE (line 105) | const ONE: Self = Self(ResidueType::ONE); method random (line 107) | fn random(mut rng: impl RngCore) -> Self { method square (line 113) | fn square(&self) -> Self { method double (line 116) | fn double(&self) -> Self { method invert (line 120) | fn invert(&self) -> CtOption { method sqrt (line 127) | fn sqrt(&self) -> CtOption { method sqrt_ratio (line 134) | fn sqrt_ratio(u: &FieldElement, v: &FieldElement) -> (Choice, FieldEleme... type Repr (line 159) | type Repr = [u8; 32]; constant MODULUS (line 162) | const MODULUS: &'static str = "7ffffffffffffffffffffffffffffffffffffffff... constant NUM_BITS (line 164) | const NUM_BITS: u32 = 255; constant CAPACITY (line 165) | const CAPACITY: u32 = 254; constant TWO_INV (line 167) | const TWO_INV: Self = FieldElement(ResidueType::new(&U256::from_u8(2)).i... constant MULTIPLICATIVE_GENERATOR (line 171) | const MULTIPLICATIVE_GENERATOR: Self = Self(ResidueType::new(&U256::from... constant S (line 174) | const S: u32 = 2; constant ROOT_OF_UNITY (line 178) | const ROOT_OF_UNITY: Self = FieldElement(ResidueType::new(&U256::from_be... constant ROOT_OF_UNITY_INV (line 182) | const ROOT_OF_UNITY_INV: Self = FieldElement(Self::ROOT_OF_UNITY.0.inver... constant DELTA (line 186) | const DELTA: Self = FieldElement(ResidueType::new(&U256::from_be_hex( method from_repr (line 190) | fn from_repr(bytes: [u8; 32]) -> CtOption { method to_repr (line 194) | fn to_repr(&self) -> [u8; 32] { method is_odd (line 198) | fn is_odd(&self) -> Choice { method from_u128 (line 202) | fn from_u128(num: u128) -> Self { type ReprBits (line 208) | type ReprBits = [u8; 32]; method to_le_bits (line 210) | fn to_le_bits(&self) -> FieldBits { method char_le_bits (line 214) | fn char_le_bits() -> FieldBits { function test_wide_modulus (line 348) | fn test_wide_modulus() { function test_sqrt_m1 (line 355) | fn test_sqrt_m1() { function test_field (line 372) | fn test_field() { FILE: crypto/dalek-ff-group/src/lib.rs function black_box (line 47) | pub(crate) fn black_box(val: T) -> T { function black_box (line 54) | pub(crate) fn black_box(val: T) -> T { function u8_from_bool (line 60) | fn u8_from_bool(bit_ref: &mut bool) -> u8 { function choice (line 74) | fn choice(mut value: bool) -> Choice { type Scalar (line 179) | pub struct Scalar(pub DScalar); method pow (line 201) | pub fn pow(&self, other: Scalar) -> Scalar { method from_bytes_mod_order_wide (line 239) | pub fn from_bytes_mod_order_wide(bytes: &[u8; 64]) -> Scalar { method from_hash (line 244) | pub fn from_hash + HashMarker>(hash: D) ->... method from_uniform_bytes (line 329) | fn from_uniform_bytes(bytes: &[u8; 64]) -> Self { method sum (line 335) | fn sum>(iter: I) -> Scalar { method sum (line 341) | fn sum>(iter: I) -> Scalar { method product (line 347) | fn product>(iter: I) -> Scalar { method product (line 353) | fn product>(iter: I) -> Scalar { constant ZERO (line 254) | const ZERO: Scalar = Scalar(DScalar::ZERO); constant ONE (line 255) | const ONE: Scalar = Scalar(DScalar::ONE); method random (line 257) | fn random(rng: impl RngCore) -> Self { method square (line 261) | fn square(&self) -> Self { method double (line 264) | fn double(&self) -> Self { method invert (line 267) | fn invert(&self) -> CtOption { method sqrt (line 271) | fn sqrt(&self) -> CtOption { method sqrt_ratio (line 275) | fn sqrt_ratio(num: &Self, div: &Self) -> (Choice, Self) { type Repr (line 282) | type Repr = [u8; 32]; constant MODULUS (line 284) | const MODULUS: &'static str = ::MODULUS; constant NUM_BITS (line 286) | const NUM_BITS: u32 = ::NUM_BITS; constant CAPACITY (line 287) | const CAPACITY: u32 = ::CAPACITY; constant TWO_INV (line 289) | const TWO_INV: Scalar = Scalar(::TWO_INV); constant MULTIPLICATIVE_GENERATOR (line 291) | const MULTIPLICATIVE_GENERATOR: Scalar = constant S (line 293) | const S: u32 = ::S; constant ROOT_OF_UNITY (line 295) | const ROOT_OF_UNITY: Scalar = Scalar(::ROOT_OF_UN... constant ROOT_OF_UNITY_INV (line 296) | const ROOT_OF_UNITY_INV: Scalar = Scalar(::ROOT_O... constant DELTA (line 298) | const DELTA: Scalar = Scalar(::DELTA); method from_repr (line 300) | fn from_repr(bytes: [u8; 32]) -> CtOption { method to_repr (line 303) | fn to_repr(&self) -> [u8; 32] { method is_odd (line 307) | fn is_odd(&self) -> Choice { method from_u128 (line 311) | fn from_u128(num: u128) -> Self { type ReprBits (line 317) | type ReprBits = [u8; 32]; method to_le_bits (line 319) | fn to_le_bits(&self) -> FieldBits { method char_le_bits (line 323) | fn char_le_bits() -> FieldBits { method mul_by_cofactor (line 481) | pub fn mul_by_cofactor(&self) -> EdwardsPoint { function test_ed25519_group (line 497) | fn test_ed25519_group() { function test_ristretto_group (line 502) | fn test_ristretto_group() { FILE: crypto/dkg/dealer/src/lib.rs function key_gen (line 18) | pub fn key_gen( FILE: crypto/dkg/musig/src/lib.rs type MusigError (line 23) | pub enum MusigError { function check_keys (line 46) | fn check_keys(keys: &[C::G]) -> Result( function binding_factor (line 81) | fn binding_factor(mut transcript: Vec, i: u16) -> C:... function musig_key_multiexp (line 87) | fn musig_key_multiexp( function musig_key_vartime (line 103) | pub fn musig_key_vartime( function musig_key (line 111) | pub fn musig_key(context: [u8; 32], keys: &[C::G]) -> Re... function musig (line 116) | pub fn musig( FILE: crypto/dkg/musig/src/tests.rs function test_musig (line 14) | pub fn test_musig() { FILE: crypto/dkg/pedpop/src/encryption.rs type ReadWrite (line 29) | pub trait ReadWrite: Sized { method read (line 30) | fn read(reader: &mut R, params: ThresholdParams) -> io::R... method write (line 31) | fn write(&self, writer: &mut W) -> io::Result<()>; method serialize (line 33) | fn serialize(&self) -> Vec { type Message (line 40) | pub trait Message: Clone + PartialEq + Eq + fmt::Debug + Zeroize + ReadW... type Encryptable (line 43) | pub trait Encryptable: Clone + AsRef<[u8]> + AsMut<[u8]> + Zeroize + Rea... type EncryptionKeyMessage (line 50) | pub struct EncryptionKeyMessage { function read (line 57) | pub fn read(reader: &mut R, params: ThresholdParams) -> io:... function write (line 61) | pub fn write(&self, writer: &mut W) -> io::Result<()> { function serialize (line 66) | pub fn serialize(&self) -> Vec { function enc_key (line 73) | pub(crate) fn enc_key(&self) -> C::G { type EncryptedMessage (line 81) | pub struct EncryptedMessage { function ecdh (line 95) | fn ecdh(private: &Zeroizing, public: C::G) -> Zero... function cipher (line 101) | fn cipher(context: [u8; 32], ecdh: &Zeroizing) -> ... function encrypt (line 135) | fn encrypt( function read (line 171) | pub fn read(reader: &mut R, params: ThresholdParams) -> io:... function write (line 179) | pub fn write(&self, writer: &mut W) -> io::Result<()> { function serialize (line 185) | pub fn serialize(&self) -> Vec { function invalidate_pop (line 192) | pub(crate) fn invalidate_pop(&mut self) { function invalidate_msg (line 197) | pub(crate) fn invalidate_msg( function invalidate_share_serialization (line 219) | pub(crate) fn invalidate_share_serialization( function invalidate_share_value (line 243) | pub(crate) fn invalidate_share_value( type EncryptionKeyProof (line 261) | pub struct EncryptionKeyProof { function read (line 267) | pub fn read(reader: &mut R) -> io::Result { function write (line 271) | pub fn write(&self, writer: &mut W) -> io::Result<()> { function serialize (line 276) | pub fn serialize(&self) -> Vec { function invalidate_key (line 283) | pub(crate) fn invalidate_key(&mut self) { function invalidate_dleq (line 288) | pub(crate) fn invalidate_dleq(&mut self) { function pop_challenge (line 302) | fn pop_challenge( function encryption_key_transcript (line 326) | fn encryption_key_transcript(context: [u8; 32]) -> RecommendedTranscript { type DecryptionError (line 333) | pub(crate) enum DecryptionError { type Decryption (line 342) | pub(crate) struct Decryption { function new (line 348) | pub(crate) fn new(context: [u8; 32]) -> Self { function register (line 351) | pub(crate) fn register( function decrypt_with_proof (line 366) | pub(crate) fn decrypt_with_proof( type Encryption (line 402) | pub(crate) struct Encryption { function fmt (line 411) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { method zeroize (line 423) | fn zeroize(&mut self) { function new (line 433) | pub(crate) fn new( function registration (line 448) | pub(crate) fn registration(&self, msg: M) -> EncryptionKeyMe... function register (line 452) | pub(crate) fn register( function encrypt (line 460) | pub(crate) fn encrypt( function decrypt (line 469) | pub(crate) fn decrypt Decryption { FILE: crypto/dkg/pedpop/src/lib.rs type PedPoPError (line 38) | pub enum PedPoPError { function validate_map (line 57) | fn validate_map( function challenge (line 86) | fn challenge(context: [u8; 32], l: Participant, R: &[u8]... type Commitments (line 103) | pub struct Commitments { method read (line 110) | fn read(reader: &mut R, params: ThresholdParams) -> io::Result<... method write (line 130) | fn write(&self, writer: &mut W) -> io::Result<()> { type KeyGenMachine (line 138) | pub struct KeyGenMachine { function new (line 148) | pub fn new(params: ThresholdParams, context: [u8; 32]) -> KeyGenMachine<... function generate_coefficients (line 156) | pub fn generate_coefficients( function polynomial (line 205) | fn polynomial( type SecretShare (line 231) | pub struct SecretShare(F::Repr); function as_ref (line 233) | fn as_ref(&self) -> &[u8] { function as_mut (line 238) | fn as_mut(&mut self) -> &mut [u8] { function fmt (line 243) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { method zeroize (line 248) | fn zeroize(&mut self) { method drop (line 257) | fn drop(&mut self) { method read (line 264) | fn read(reader: &mut R, _: ThresholdParams) -> io::Result { method write (line 270) | fn write(&self, writer: &mut W) -> io::Result<()> { type SecretShareMachine (line 277) | pub struct SecretShareMachine { function fmt (line 286) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { function verify_r1 (line 300) | fn verify_r1( function generate_secret_shares (line 347) | pub fn generate_secret_shares( type KeyMachine (line 388) | pub struct KeyMachine { function fmt (line 396) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { method zeroize (line 407) | fn zeroize(&mut self) { function exponential (line 420) | fn exponential(i: Participant, values: &[C::G]) -> Vec<(... function share_verification_statements (line 430) | fn share_verification_statements( type BatchId (line 452) | enum BatchId { function calculate_share (line 463) | pub fn calculate_share( type BlameMachine (line 536) | pub struct BlameMachine { function fmt (line 543) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { method zeroize (line 553) | fn zeroize(&mut self) { function complete (line 571) | pub fn complete(self) -> ThresholdKeys { function blame_internal (line 575) | fn blame_internal( function blame (line 623) | pub fn blame( type AdditionalBlameMachine (line 637) | pub struct AdditionalBlameMachine(BlameMachine); function new (line 649) | pub fn new( function blame (line 674) | pub fn blame( FILE: crypto/dkg/pedpop/src/tests.rs constant THRESHOLD (line 10) | const THRESHOLD: u16 = 3; constant PARTICIPANTS (line 11) | const PARTICIPANTS: u16 = 5; function clone_without (line 14) | fn clone_without( type PedPoPEncryptedMessage (line 23) | type PedPoPEncryptedMessage = EncryptedMessage = HashMap( function generate_secret_shares (line 83) | fn generate_secret_shares( function pedpop_gen (line 98) | fn pedpop_gen( constant ONE (line 141) | const ONE: Participant = Participant::new(1).unwrap(); constant TWO (line 142) | const TWO: Participant = Participant::new(2).unwrap(); function test_pedpop (line 145) | fn test_pedpop() { function test_blame (line 149) | fn test_blame( function invalid_encryption_pop_blame (line 176) | fn invalid_encryption_pop_blame() { function invalid_ecdh_blame (line 208) | fn invalid_ecdh_blame() { function invalid_dleq_blame (line 249) | fn invalid_dleq_blame() { function invalid_share_serialization_blame (line 283) | fn invalid_share_serialization_blame() { function invalid_share_value_blame (line 316) | fn invalid_share_value_blame() { FILE: crypto/dkg/promote/src/lib.rs type PromotionError (line 26) | pub enum PromotionError { function transcript (line 52) | fn transcript(key: &G, i: Participant) -> RecommendedT... type GeneratorProof (line 61) | pub struct GeneratorProof { function write (line 67) | pub fn write(&self, writer: &mut W) -> io::Result<()> { function read (line 72) | pub fn read(reader: &mut R) -> io::Result> { function serialize (line 79) | pub fn serialize(&self) -> Vec { type GeneratorPromotion (line 91) | pub struct GeneratorPromotion { function promote (line 101) | pub fn promote( function complete (line 120) | pub fn complete( FILE: crypto/dkg/promote/src/tests.rs type AltGenerator (line 18) | struct AltGenerator { type F (line 23) | type F = C::F; type G (line 24) | type G = C::G; type H (line 25) | type H = C::H; constant ID (line 27) | const ID: &'static [u8] = b"Alternate Ciphersuite"; method generator (line 29) | fn generator() -> Self::G { method hash_to_F (line 33) | fn hash_to_F(dst: &[u8], data: &[u8]) -> Self::F { function clone_without (line 39) | pub fn clone_without( FILE: crypto/dkg/src/lib.rs type Participant (line 26) | pub struct Participant(u16); method new (line 29) | pub const fn new(i: u16) -> Option { method to_bytes (line 39) | pub const fn to_bytes(&self) -> [u8; 2] { method fmt (line 51) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { method deserialize_reader (line 122) | fn deserialize_reader(reader: &mut R) -> io::Result { function from (line 45) | fn from(participant: Participant) -> u16 { type DkgError (line 58) | pub enum DkgError { type ThresholdParams (line 131) | pub struct ThresholdParams { method new (line 166) | pub const fn new(t: u16, n: u16, i: Participant) -> Result u16 { method n (line 186) | pub const fn n(&self) -> u16 { method i (line 190) | pub const fn i(&self) -> Participant { method all_participant_indexes (line 195) | pub fn all_participant_indexes(&self) -> impl Iterator(reader: &mut R) -> io::Result { type AllParticipantIndexes (line 141) | struct AllParticipantIndexes { type Item (line 146) | type Item = Participant; method next (line 147) | fn next(&mut self) -> Option { type Interpolation (line 212) | pub enum Interpolation { function interpolation_factor (line 226) | fn interpolation_factor(&self, i: Participant, included: &[Participant])... type ThresholdCore (line 258) | struct ThresholdCore { function fmt (line 267) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { method zeroize (line 279) | fn zeroize(&mut self) { type ThresholdKeys (line 292) | pub struct ThresholdKeys { type ThresholdView (line 305) | pub struct ThresholdView { function fmt (line 317) | fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { method zeroize (line 332) | fn zeroize(&mut self) { function new (line 349) | pub fn new( function scale (line 400) | pub fn scale(mut self, scalar: C::F) -> Option> { function offset (line 414) | pub fn offset(mut self, offset: C::F) -> ThresholdKeys { function current_scalar (line 420) | pub fn current_scalar(&self) -> C::F { function current_offset (line 425) | pub fn current_offset(&self) -> C::F { function params (line 430) | pub fn params(&self) -> ThresholdParams { function original_group_key (line 435) | pub fn original_group_key(&self) -> C::G { function interpolation (line 440) | pub fn interpolation(&self) -> &Interpolation