Full Code of nervosnetwork/muta for AI

gitextract_lg42y7z7/

├── .dockerignore
├── .github/
│   ├── CODEOWNERS
│   ├── ISSUE_TEMPLATE/
│   │   ├── bug-report.md
│   │   ├── feature.md
│   │   └── help.md
│   ├── PULL_REQUEST_TEMPLATE.md
│   └── semantic.yml
├── .gitignore
├── .helmignore
├── CHANGELOG/
│   ├── CHANGELOG-0.1.md
│   ├── CHANGELOG-0.2.md
│   └── README.md
├── CONTRIBUTING.md
├── Cargo.toml
├── LICENSE
├── Makefile
├── OWNERS
├── OWNERS_ALIASES
├── README.md
├── README_CN.md
├── SECURITY.md
├── benchmark/
│   ├── bench_executor.rs
│   ├── bench_mempool.rs
│   ├── benchmark_genesis.toml
│   ├── governance/
│   │   ├── mod.rs
│   │   └── types.rs
│   └── mod.rs
├── binding-macro/
│   ├── Cargo.toml
│   ├── src/
│   │   ├── common.rs
│   │   ├── cycles.rs
│   │   ├── hooks.rs
│   │   ├── lib.rs
│   │   ├── read_write.rs
│   │   └── service.rs
│   └── tests/
│       └── mod.rs
├── built-in-services/
│   ├── asset/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── lib.rs
│   │       ├── tests/
│   │       │   └── mod.rs
│   │       └── types.rs
│   ├── authorization/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── metadata/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── lib.rs
│   │       └── tests/
│   │           └── mod.rs
│   ├── multi-signature/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── lib.rs
│   │       ├── tests/
│   │       │   ├── curd_test.rs
│   │       │   ├── mod.rs
│   │       │   └── recursion_test.rs
│   │       └── types.rs
│   └── util/
│       ├── Cargo.toml
│       └── src/
│           ├── lib.rs
│           ├── tests/
│           │   └── mod.rs
│           └── types.rs
├── byzantine/
│   ├── Cargo.toml
│   ├── README.md
│   ├── generators.toml
│   ├── src/
│   │   ├── behaviors.rs
│   │   ├── commander.rs
│   │   ├── config.rs
│   │   ├── default_start.rs
│   │   ├── invalid_types.rs
│   │   ├── lib.rs
│   │   ├── message.rs
│   │   ├── strategy.rs
│   │   ├── utils.rs
│   │   └── worker.rs
│   └── tests/
│       ├── byz.test.ts
│       ├── jest.config.js
│       └── package.json
├── charts/
│   ├── deploy-chaos/
│   │   ├── .helmignore
│   │   ├── Chart.yaml
│   │   ├── templates/
│   │   │   ├── _helpers.tpl
│   │   │   ├── muta-benchmark.yaml
│   │   │   └── muta-chaos-crd.yaml
│   │   └── values.yaml
│   ├── muta/
│   │   ├── .helmignore
│   │   ├── Chart.yaml
│   │   ├── Makefile
│   │   ├── README.md
│   │   ├── templates/
│   │   │   ├── NOTES.txt
│   │   │   ├── _helpers.tpl
│   │   │   ├── canary.yaml
│   │   │   ├── deployment.yaml
│   │   │   ├── hpa.yaml
│   │   │   ├── ingress.yaml
│   │   │   ├── ksvc.yaml
│   │   │   └── service.yaml
│   │   └── values.yaml
│   └── preview/
│       ├── Chart.yaml
│       ├── Makefile
│       ├── requirements.yaml
│       └── values.yaml
├── clippy.toml
├── common/
│   ├── apm/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   └── src/
│   │       ├── lib.rs
│   │       ├── metrics/
│   │       │   ├── api.rs
│   │       │   ├── consensus.rs
│   │       │   ├── mempool.rs
│   │       │   ├── network.rs
│   │       │   └── storage.rs
│   │       └── metrics.rs
│   ├── channel/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── config-parser/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── lib.rs
│   │       └── types.rs
│   ├── crypto/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   ├── logger/
│   │   ├── Cargo.toml
│   │   ├── README.md
│   │   ├── log.yml
│   │   └── src/
│   │       ├── date_fixed_roller.rs
│   │       └── lib.rs
│   ├── merkle/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   └── pubsub/
│       ├── Cargo.toml
│       └── src/
│           └── lib.rs
├── core/
│   ├── api/
│   │   ├── Cargo.toml
│   │   ├── source/
│   │   │   └── graphiql.html
│   │   └── src/
│   │       ├── adapter/
│   │       │   └── mod.rs
│   │       ├── config.rs
│   │       ├── lib.rs
│   │       └── schema/
│   │           ├── block.rs
│   │           ├── mod.rs
│   │           ├── receipt.rs
│   │           └── transaction.rs
│   ├── cli/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── error.rs
│   │       ├── lib.rs
│   │       └── tests/
│   │           ├── config.toml
│   │           ├── genesis.toml
│   │           ├── mod.rs
│   │           └── service_mapping.rs
│   ├── consensus/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── adapter.rs
│   │       ├── consensus.rs
│   │       ├── engine.rs
│   │       ├── fixed_types.rs
│   │       ├── lib.rs
│   │       ├── message.rs
│   │       ├── status.rs
│   │       ├── synchronization.rs
│   │       ├── tests/
│   │       │   ├── engine.rs
│   │       │   ├── mod.rs
│   │       │   ├── status.rs
│   │       │   └── synchronization.rs
│   │       ├── util.rs
│   │       ├── wal.rs
│   │       └── wal_proto.rs
│   ├── mempool/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── adapter/
│   │       │   ├── message.rs
│   │       │   └── mod.rs
│   │       ├── context.rs
│   │       ├── lib.rs
│   │       ├── map.rs
│   │       ├── tests/
│   │       │   ├── mempool.rs
│   │       │   └── mod.rs
│   │       └── tx_cache.rs
│   ├── network/
│   │   ├── Cargo.toml
│   │   ├── examples/
│   │   │   └── buycopy.rs
│   │   ├── src/
│   │   │   ├── common.rs
│   │   │   ├── compression/
│   │   │   │   ├── mod.rs
│   │   │   │   └── snappy.rs
│   │   │   ├── config.rs
│   │   │   ├── connection/
│   │   │   │   ├── control.rs
│   │   │   │   ├── keeper.rs
│   │   │   │   └── mod.rs
│   │   │   ├── endpoint.rs
│   │   │   ├── error.rs
│   │   │   ├── event.rs
│   │   │   ├── lib.rs
│   │   │   ├── message/
│   │   │   │   ├── mod.rs
│   │   │   │   ├── serde.rs
│   │   │   │   └── serde_multi.rs
│   │   │   ├── metrics.rs
│   │   │   ├── outbound/
│   │   │   │   ├── gossip.rs
│   │   │   │   ├── mod.rs
│   │   │   │   └── rpc.rs
│   │   │   ├── peer_manager/
│   │   │   │   ├── addr_set.rs
│   │   │   │   ├── diagnostic.rs
│   │   │   │   ├── mod.rs
│   │   │   │   ├── peer.rs
│   │   │   │   ├── retry.rs
│   │   │   │   ├── save_restore.rs
│   │   │   │   ├── session_book.rs
│   │   │   │   ├── shared.rs
│   │   │   │   ├── tags.rs
│   │   │   │   ├── test_manager.rs
│   │   │   │   ├── time.rs
│   │   │   │   └── trust_metric.rs
│   │   │   ├── protocols/
│   │   │   │   ├── core.rs
│   │   │   │   ├── discovery/
│   │   │   │   │   ├── addr.rs
│   │   │   │   │   ├── behaviour.rs
│   │   │   │   │   ├── message.rs
│   │   │   │   │   ├── protocol.rs
│   │   │   │   │   └── substream.rs
│   │   │   │   ├── discovery.rs
│   │   │   │   ├── identify/
│   │   │   │   │   ├── behaviour.rs
│   │   │   │   │   ├── common.rs
│   │   │   │   │   ├── identification.rs
│   │   │   │   │   ├── message.rs
│   │   │   │   │   ├── protocol.rs
│   │   │   │   │   └── tests.rs
│   │   │   │   ├── identify.rs
│   │   │   │   ├── macro.rs
│   │   │   │   ├── mod.rs
│   │   │   │   ├── ping/
│   │   │   │   │   ├── behaviour.rs
│   │   │   │   │   ├── message.rs
│   │   │   │   │   └── protocol.rs
│   │   │   │   ├── ping.rs
│   │   │   │   ├── transmitter/
│   │   │   │   │   ├── behaviour.rs
│   │   │   │   │   ├── message.rs
│   │   │   │   │   └── protocol.rs
│   │   │   │   └── transmitter.rs
│   │   │   ├── reactor/
│   │   │   │   ├── mod.rs
│   │   │   │   ├── router.rs
│   │   │   │   └── rpc_map.rs
│   │   │   ├── rpc.rs
│   │   │   ├── selfcheck.rs
│   │   │   ├── service.rs
│   │   │   ├── test/
│   │   │   │   └── mock.rs
│   │   │   ├── test.rs
│   │   │   └── traits.rs
│   │   └── tests/
│   │       ├── common.rs
│   │       └── gossip_test.rs
│   ├── run/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       └── lib.rs
│   └── storage/
│       ├── Cargo.toml
│       ├── examples/
│       │   └── bench.rs
│       └── src/
│           ├── adapter/
│           │   ├── memory.rs
│           │   ├── mod.rs
│           │   └── rocks.rs
│           ├── lib.rs
│           └── tests/
│               ├── adapter.rs
│               ├── mod.rs
│               └── storage.rs
├── devtools/
│   ├── chain/
│   │   ├── README.md
│   │   ├── config.toml
│   │   └── genesis.toml
│   ├── docker-build/
│   │   ├── Dockerfile
│   │   ├── Dockerfile.build-env
│   │   └── Dockerfile.e2e-env
│   ├── keypair/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── keypair.yml
│   │       └── main.rs
│   └── kube/
│       └── deploy-chaos-crd-template.yml
├── docs/
│   ├── _config.yml
│   ├── build/
│   │   └── gql_api.sh
│   ├── graphql_api.md
│   ├── how_to_deploy_a_core_crate.md
│   ├── layout.md
│   └── resources.md
├── examples/
│   ├── byzantine_node.rs
│   ├── config-1.toml
│   ├── config-2.toml
│   ├── config-3.toml
│   ├── config-4.toml
│   ├── genesis.toml
│   └── muta-chain.rs
├── framework/
│   ├── Cargo.toml
│   └── src/
│       ├── binding/
│       │   ├── mod.rs
│       │   ├── sdk/
│       │   │   ├── chain_querier.rs
│       │   │   └── mod.rs
│       │   ├── state/
│       │   │   ├── mod.rs
│       │   │   ├── trie.rs
│       │   │   └── trie_db.rs
│       │   ├── store/
│       │   │   ├── array.rs
│       │   │   ├── map.rs
│       │   │   ├── mod.rs
│       │   │   └── primitive.rs
│       │   └── tests/
│       │       ├── mod.rs
│       │       ├── sdk.rs
│       │       ├── state.rs
│       │       └── store.rs
│       ├── executor/
│       │   ├── error.rs
│       │   ├── factory.rs
│       │   ├── mod.rs
│       │   └── tests/
│       │       ├── framework.rs
│       │       ├── framework_genesis_services.toml
│       │       ├── genesis_services.toml
│       │       ├── mod.rs
│       │       └── test_service.rs
│       └── lib.rs
├── jenkins-x-chaos.yml
├── jenkins-x-e2e.yml
├── jenkins-x-lint.yml
├── jenkins-x-unit.yml
├── jenkins-x.yml
├── protocol/
│   ├── Cargo.toml
│   └── src/
│       ├── codec/
│       │   ├── block.rs
│       │   ├── macro.rs
│       │   ├── mod.rs
│       │   ├── primitive.rs
│       │   ├── receipt.rs
│       │   ├── tests/
│       │   │   └── mod.rs
│       │   └── transaction.rs
│       ├── fixed_codec/
│       │   ├── mod.rs
│       │   ├── primitive.rs
│       │   ├── receipt.rs
│       │   ├── tests/
│       │   │   ├── fixed_codec.rs
│       │   │   └── mod.rs
│       │   └── transaction.rs
│       ├── lib.rs
│       ├── traits/
│       │   ├── api.rs
│       │   ├── binding.rs
│       │   ├── consensus.rs
│       │   ├── executor.rs
│       │   ├── mempool.rs
│       │   ├── mod.rs
│       │   ├── network.rs
│       │   └── storage.rs
│       └── types/
│           ├── block.rs
│           ├── genesis.rs
│           ├── mod.rs
│           ├── primitive.rs
│           ├── receipt.rs
│           ├── service_context.rs
│           └── transaction.rs
├── rust-toolchain
├── rustfmt.toml
├── src/
│   └── lib.rs
└── tests/
    ├── common/
    │   ├── mod.rs
    │   ├── node/
    │   │   ├── config.rs
    │   │   ├── consts.rs
    │   │   ├── diagnostic.rs
    │   │   ├── full_node/
    │   │   │   ├── builder.rs
    │   │   │   ├── default_start.rs
    │   │   │   ├── error.rs
    │   │   │   └── memory_db.rs
    │   │   ├── full_node.rs
    │   │   └── sync.rs
    │   └── node.rs
    ├── e2e/
    │   ├── jest.config.js
    │   ├── package.json
    │   ├── sdk.test.ts
    │   ├── tsconfig.json
    │   ├── utils.ts
    │   └── wait-for-it.sh
    ├── trust_metric.rs
    ├── trust_metric_all/
    │   ├── client_node.rs
    │   ├── common.rs
    │   ├── consensus.rs
    │   ├── logger.rs
    │   ├── mempool.rs
    │   └── mod.rs
    └── verify_chain_id.rs

SYMBOL INDEX (3561 symbols across 216 files)

FILE: benchmark/bench_executor.rs
  function bench_execute (line 12) | fn bench_execute(b: &mut Bencher) {
  function bench_execute_with_assets (line 36) | fn bench_execute_with_assets(b: &mut Bencher) {
  function create_assets (line 55) | fn create_assets(bench_adapter: &mut BenchmarkAdapter, num: u64) {

FILE: benchmark/governance/mod.rs
  constant INFO_KEY (line 19) | const INFO_KEY: &str = "admin";
  constant TX_FEE_INLET_KEY (line 20) | const TX_FEE_INLET_KEY: &str = "fee_address";
  constant MINER_PROFIT_OUTLET_KEY (line 21) | const MINER_PROFIT_OUTLET_KEY: &str = "miner_address";
  type GovernanceService (line 28) | pub struct GovernanceService<A, SDK> {
  function new (line 37) | pub fn new(mut sdk: SDK, asset: A) -> Self {
  function init_genesis (line 49) | fn init_genesis(&mut self, payload: InitGenesisPayload) {
  function pledge_fee (line 69) | fn pledge_fee(&mut self, ctx: ServiceContext) -> ServiceResponse<String> {
  function deduct_fee (line 96) | fn deduct_fee(&mut self, ctx: ServiceContext) -> ServiceResponse<String> {
  function handle_miner_profit (line 117) | fn handle_miner_profit(&mut self, params: &ExecutorParams) {
  type ServiceError (line 168) | pub enum ServiceError {
    method code (line 185) | fn code(&self) -> u64 {
  function from (line 197) | fn from(err: ServiceError) -> ServiceResponse<T> {

FILE: benchmark/governance/types.rs
  type InitGenesisPayload (line 11) | pub struct InitGenesisPayload {
  type MinerChargeConfig (line 19) | pub struct MinerChargeConfig {
  type GovernanceInfo (line 25) | pub struct GovernanceInfo {
  type DiscountLevel (line 35) | pub struct DiscountLevel {
  method partial_cmp (line 41) | fn partial_cmp(&self, other: &DiscountLevel) -> Option<Ordering> {
  method cmp (line 47) | fn cmp(&self, other: &DiscountLevel) -> Ordering {
  type RecordProfitEvent (line 53) | pub struct RecordProfitEvent {
  type AccumulateProfitPayload (line 59) | pub struct AccumulateProfitPayload {
  type HookTransferFromPayload (line 65) | pub struct HookTransferFromPayload {

FILE: benchmark/mod.rs
  constant TRIE_PATH (line 30) | const TRIE_PATH: &str = "./free-space/state";
  constant STORAGE_PATH (line 31) | const STORAGE_PATH: &str = "./free-space/block";
  type BenchmarkAdapter (line 77) | pub struct BenchmarkAdapter {
    method new (line 92) | pub fn new() -> Self {
    method create_executor (line 134) | pub fn create_executor(
    method create_params (line 146) | pub fn create_params(&mut self) -> ExecutorParams {
    method create_mempool_adapter (line 156) | pub fn create_mempool_adapter(
    method next_height (line 176) | pub fn next_height(&mut self) {
    method create_genesis_block (line 181) | fn create_genesis_block(state_root: MerkleRoot) -> Block {
  method default (line 86) | fn default() -> Self {
  function construct_stx (line 213) | pub fn construct_stx(req: TransactionRequest) -> SignedTransaction {
  type MockServiceMapping (line 235) | pub struct MockServiceMapping;
  method get_service (line 238) | fn get_service<SDK: 'static + ServiceSDK, Factory: SDKFactory<SDK>>(
  method list_service_name (line 265) | fn list_service_name(&self) -> Vec<String> {

FILE: binding-macro/src/common.rs
  function get_request_context_pat (line 3) | pub fn get_request_context_pat(bound_name: &str, fn_arg: &FnArg) -> Opti...
  function path_is_request_context (line 15) | fn path_is_request_context(path: &Path, bound_name: &str) -> bool {
  function assert_type (line 25) | pub fn assert_type(ty: &Type, ty_str: &str) {
  function assert_reference_type (line 37) | pub fn assert_reference_type(ty: &Type, ty_str: &str) {
  function arg_is_mutable_receiver (line 48) | pub fn arg_is_mutable_receiver(fn_arg: &FnArg) -> bool {
  function arg_is_immutable_receiver (line 56) | pub fn arg_is_immutable_receiver(fn_arg: &FnArg) -> bool {

FILE: binding-macro/src/cycles.rs
  type Cycles (line 13) | struct Cycles {
  method parse (line 18) | fn parse(input: ParseStream) -> Result<Self> {
  type CyclesFnItem (line 25) | struct CyclesFnItem {
  method parse (line 35) | fn parse(input: ParseStream) -> Result<Self> {
  function gen_cycles_code (line 60) | pub fn gen_cycles_code(attr: TokenStream, item: TokenStream) -> TokenStr...
  function find_request_ident (line 92) | fn find_request_ident(bound_name: &str, inputs: &Punctuated<FnArg, Token...

FILE: binding-macro/src/hooks.rs
  function verify_hook (line 7) | pub fn verify_hook(item: TokenStream) -> TokenStream {

FILE: binding-macro/src/lib.rs
  function genesis (line 52) | pub fn genesis(_: TokenStream, item: TokenStream) -> TokenStream {
  function tx_hook_before (line 57) | pub fn tx_hook_before(_: TokenStream, item: TokenStream) -> TokenStream {
  function tx_hook_after (line 62) | pub fn tx_hook_after(_: TokenStream, item: TokenStream) -> TokenStream {
  function read (line 94) | pub fn read(_: TokenStream, item: TokenStream) -> TokenStream {
  function write (line 127) | pub fn write(_: TokenStream, item: TokenStream) -> TokenStream {
  function cycles (line 153) | pub fn cycles(attr: TokenStream, item: TokenStream) -> TokenStream {
  function hook_after (line 160) | pub fn hook_after(_: TokenStream, item: TokenStream) -> TokenStream {
  function hook_before (line 167) | pub fn hook_before(_: TokenStream, item: TokenStream) -> TokenStream {
  function service (line 288) | pub fn service(attr: TokenStream, item: TokenStream) -> TokenStream {

FILE: binding-macro/src/read_write.rs
  function verify_read_or_write (line 8) | pub fn verify_read_or_write(item: TokenStream, mutable: bool) -> TokenSt...
  function verify_visibiity (line 24) | fn verify_visibiity(visibility: &Visibility) {
  function verify_inputs (line 31) | fn verify_inputs(inputs: &Punctuated<FnArg, Token![,]>, mutable: bool) {
  function verify_ret_type (line 53) | fn verify_ret_type(ret_type: &ReturnType) {

FILE: binding-macro/src/service.rs
  constant READ_ATTRIBUTE (line 5) | const READ_ATTRIBUTE: &str = "read";
  constant WRITE_ATTRIBUTE (line 6) | const WRITE_ATTRIBUTE: &str = "write";
  constant GENESIS_ATTRIBUTE (line 7) | const GENESIS_ATTRIBUTE: &str = "genesis";
  constant HOOK_BEFORE_ATTRIBUTE (line 8) | const HOOK_BEFORE_ATTRIBUTE: &str = "hook_before";
  constant HOOK_AFTER_ATTRIBUTE (line 9) | const HOOK_AFTER_ATTRIBUTE: &str = "hook_after";
  constant TX_HOOK_BEFORE_ATTRIBUTE (line 10) | const TX_HOOK_BEFORE_ATTRIBUTE: &str = "tx_hook_before";
  constant TX_HOOK_AFTER_ATTRIBUTE (line 11) | const TX_HOOK_AFTER_ATTRIBUTE: &str = "tx_hook_after";
  type ServiceMethod (line 13) | enum ServiceMethod {
  type Hooks (line 18) | struct Hooks {
  type MethodMeta (line 25) | struct MethodMeta {
  function gen_service_code (line 31) | pub fn gen_service_code(_: TokenStream, item: TokenStream) -> TokenStream {
  function split_list_for_metadata (line 215) | fn split_list_for_metadata(
  function split_list_for_metadata_nonepayload (line 238) | fn split_list_for_metadata_nonepayload(
  function get_service_ident (line 254) | fn get_service_ident(impl_item: &ItemImpl) -> Ident {
  function find_service_method (line 261) | fn find_service_method(method: &ImplItemMethod) -> Option<ServiceMethod> {
  function find_genesis (line 277) | fn find_genesis(items: &[ImplItem]) -> Option<ImplItemMethod> {
  function get_genesis_body (line 301) | fn get_genesis_body(item: &ImplItemMethod) -> proc_macro2::TokenStream {
  function extract_hooks (line 328) | fn extract_hooks(items: &[ImplItem]) -> Hooks {
  function find_list_for_item_method (line 382) | fn find_list_for_item_method(items: &[ImplItem]) -> Vec<ImplItemMethod> {
  function extract_method_meta (line 396) | fn extract_method_meta(method: ServiceMethod) -> MethodMeta {

FILE: binding-macro/tests/mod.rs
  function test_read_and_write (line 21) | fn test_read_and_write() {
  function test_hooks (line 48) | fn test_hooks() {
  function test_tx_hooks (line 74) | fn test_tx_hooks() {
  function test_read_and_write_with_noneparams (line 104) | fn test_read_and_write_with_noneparams() {
  function test_cycles (line 128) | fn test_cycles() {
  function test_service (line 170) | fn test_service() {
  function test_service_none_payload (line 273) | fn test_service_none_payload() {
  function test_service_none_response (line 355) | fn test_service_none_response() {
  function get_context (line 423) | fn get_context(cycles_limit: u64, service: &str, method: &str, payload: ...
  function mock_executor_params (line 443) | fn mock_executor_params() -> ExecutorParams {
  type MockServiceSDK (line 453) | struct MockServiceSDK;
  method alloc_or_recover_map (line 457) | fn alloc_or_recover_map<Key: 'static + FixedCodec + PartialEq, Val: 'sta...
  method alloc_or_recover_array (line 465) | fn alloc_or_recover_array<Elm: 'static + FixedCodec>(
  method alloc_or_recover_uint64 (line 473) | fn alloc_or_recover_uint64(&mut self, _var_name: &str) -> Box<dyn StoreU...
  method alloc_or_recover_string (line 478) | fn alloc_or_recover_string(&mut self, _var_name: &str) -> Box<dyn StoreS...
  method alloc_or_recover_bool (line 483) | fn alloc_or_recover_bool(&mut self, _var_name: &str) -> Box<dyn StoreBoo...
  method get_value (line 488) | fn get_value<Key: FixedCodec, Ret: FixedCodec>(&self, _key: &Key) -> Opt...
  method set_value (line 493) | fn set_value<Key: FixedCodec, Val: FixedCodec>(&mut self, _key: Key, _va...
  method get_account_value (line 498) | fn get_account_value<Key: FixedCodec, Ret: FixedCodec>(
  method set_account_value (line 507) | fn set_account_value<Key: FixedCodec, Val: FixedCodec>(
  method get_transaction_by_hash (line 518) | fn get_transaction_by_hash(&self, _tx_hash: &Hash) -> Option<SignedTrans...
  method get_block_by_height (line 525) | fn get_block_by_height(&self, _height: Option<u64>) -> Option<Block> {
  method get_receipt_by_hash (line 531) | fn get_receipt_by_hash(&self, _tx_hash: &Hash) -> Option<Receipt> {

FILE: built-in-services/asset/src/lib.rs
  constant ASSET_SERVICE_NAME (line 20) | pub const ASSET_SERVICE_NAME: &str = "asset";
  type Assets (line 22) | pub trait Assets {
    method create_ (line 23) | fn create_(&mut self, ctx: &ServiceContext, payload: CreateAssetPayload)
    method balance_ (line 26) | fn balance_(
    method transfer_ (line 32) | fn transfer_(&mut self, ctx: &ServiceContext, payload: TransferPayload...
    method transfer_from_ (line 34) | fn transfer_from_(
    method allowance_ (line 40) | fn allowance_(
    method create_ (line 53) | fn create_(
    method balance_ (line 63) | fn balance_(
    method transfer_ (line 71) | fn transfer_(&mut self, ctx: &ServiceContext, payload: TransferPayload...
    method transfer_from_ (line 75) | fn transfer_from_(
    method allowance_ (line 83) | fn allowance_(
  type AssetService (line 47) | pub struct AssetService<SDK> {
  function new (line 94) | pub fn new(mut sdk: SDK) -> Self {
  function init_genesis (line 101) | fn init_genesis(&mut self, payload: InitGenesisPayload) {
  function get_asset (line 123) | fn get_asset(&self, ctx: ServiceContext, payload: GetAssetPayload) -> Se...
  function get_balance (line 133) | fn get_balance(
  function get_allowance (line 164) | fn get_allowance(
  function create_asset (line 203) | fn create_asset(
  function transfer (line 255) | pub fn transfer(
  function approve (line 296) | fn approve(&mut self, ctx: ServiceContext, payload: ApprovePayload) -> S...
  function transfer_from (line 349) | pub fn transfer_from(
  function _transfer (line 413) | fn _transfer(

FILE: built-in-services/asset/src/tests/mod.rs
  function test_create_asset (line 25) | fn test_create_asset() {
  function test_transfer (line 60) | fn test_transfer() {
  function test_approve (line 103) | fn test_approve() {
  function test_transfer_from (line 139) | fn test_transfer_from() {
  function new_asset_service (line 199) | fn new_asset_service(
  function mock_context (line 211) | fn mock_context(cycles_limit: u64, caller: Address) -> ServiceContext {
  type MockStorage (line 231) | struct MockStorage;
  method insert_block (line 235) | async fn insert_block(&self, _ctx: Context, _block: Block) -> ProtocolRe...
  method get_block (line 239) | async fn get_block(&self, _ctx: Context, _height: u64) -> ProtocolResult...
  method set_block (line 243) | async fn set_block(&self, _ctx: Context, _block: Block) -> ProtocolResul...
  method remove_block (line 247) | async fn remove_block(&self, _ctx: Context, _height: u64) -> ProtocolRes...
  method get_latest_block (line 251) | async fn get_latest_block(&self, _ctx: Context) -> ProtocolResult<Block> {
  method set_latest_block (line 255) | async fn set_latest_block(&self, _ctx: Context, _block: Block) -> Protoc...
  method get_latest_block_header (line 259) | async fn get_latest_block_header(&self, _ctx: Context) -> ProtocolResult...
  method get_block_header (line 263) | async fn get_block_header(
  method insert_transactions (line 274) | async fn insert_transactions(
  method insert_receipts (line 283) | async fn insert_receipts(&self, _ctx: Context, _: u64, _: Vec<Receipt>) ...
  method update_latest_proof (line 287) | async fn update_latest_proof(&self, _ctx: Context, _: Proof) -> Protocol...
  method get_transaction_by_hash (line 291) | async fn get_transaction_by_hash(
  method get_transactions (line 299) | async fn get_transactions(
  method get_receipt_by_hash (line 308) | async fn get_receipt_by_hash(&self, _ctx: Context, _: Hash) -> ProtocolR...
  method get_receipts (line 312) | async fn get_receipts(
  method get_latest_proof (line 321) | async fn get_latest_proof(&self, _ctx: Context) -> ProtocolResult<Proof> {

FILE: built-in-services/asset/src/types.rs
  type InitGenesisPayload (line 12) | pub struct InitGenesisPayload {
  type CreateAssetPayload (line 21) | pub struct CreateAssetPayload {
  type GetAssetPayload (line 28) | pub struct GetAssetPayload {
  type TransferPayload (line 33) | pub struct TransferPayload {
  type TransferEvent (line 40) | pub struct TransferEvent {
  type ApprovePayload (line 47) | pub type ApprovePayload = TransferPayload;
  type ApproveEvent (line 50) | pub struct ApproveEvent {
  type TransferFromPayload (line 58) | pub struct TransferFromPayload {
  type TransferFromEvent (line 66) | pub struct TransferFromEvent {
  type GetBalancePayload (line 75) | pub struct GetBalancePayload {
  type GetBalanceResponse (line 81) | pub struct GetBalanceResponse {
  type GetAllowancePayload (line 88) | pub struct GetAllowancePayload {
  type GetAllowanceResponse (line 95) | pub struct GetAllowanceResponse {
  type Asset (line 103) | pub struct Asset {
  type AssetBalance (line 111) | pub struct AssetBalance {
    method decode (line 123) | fn decode(rlp: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
    method rlp_append (line 136) | fn rlp_append(&self, s: &mut rlp::RlpStream) {
  type AllowanceCodec (line 117) | struct AllowanceCodec {
  method encode_fixed (line 156) | fn encode_fixed(&self) -> ProtocolResult<Bytes> {
  method decode_fixed (line 160) | fn decode_fixed(bytes: Bytes) -> ProtocolResult<Self> {

FILE: built-in-services/authorization/src/lib.rs
  constant AUTHORIZATION_SERVICE_NAME (line 8) | pub const AUTHORIZATION_SERVICE_NAME: &str = "authorization";
  type PtrSignedTransaction (line 11) | pub struct PtrSignedTransaction {
  type AuthorizationService (line 15) | pub struct AuthorizationService<SDK> {
  function new (line 22) | pub fn new(_sdk: SDK, multi_sig: MultiSignatureService<SDK>) -> Self {
  function check_authorization_by_ptr (line 28) | fn check_authorization_by_ptr(
  function check_authorization (line 43) | fn check_authorization(

FILE: built-in-services/metadata/src/lib.rs
  constant METADATA_SERVICE_NAME (line 8) | pub const METADATA_SERVICE_NAME: &str = "metadata";
  type MetaData (line 10) | pub trait MetaData {
    method get_ (line 11) | fn get_(&self, ctx: &ServiceContext) -> ServiceResponse<Metadata>;
    method get_ (line 19) | fn get_(&self, ctx: &ServiceContext) -> ServiceResponse<Metadata> {
  type MetadataService (line 14) | pub struct MetadataService<SDK> {
  function new (line 26) | pub fn new(sdk: SDK) -> Self {
  function init_genesis (line 31) | fn init_genesis(&mut self, metadata: Metadata) {
  function get_metadata (line 37) | fn get_metadata(&self, ctx: ServiceContext) -> ServiceResponse<Metadata> {

FILE: built-in-services/metadata/src/tests/mod.rs
  function test_get_metadata (line 21) | fn test_get_metadata() {
  function new_metadata_service_with_metadata (line 34) | fn new_metadata_service_with_metadata(
  function mock_metadata (line 50) | fn mock_metadata() -> Metadata {
  function mock_context (line 76) | fn mock_context(cycles_limit: u64, caller: Address) -> ServiceContext {
  type MockStorage (line 96) | struct MockStorage;
  method insert_block (line 100) | async fn insert_block(&self, _ctx: Context, _block: Block) -> ProtocolRe...
  method get_block (line 104) | async fn get_block(&self, _ctx: Context, _height: u64) -> ProtocolResult...
  method set_block (line 108) | async fn set_block(&self, _ctx: Context, _block: Block) -> ProtocolResul...
  method remove_block (line 112) | async fn remove_block(&self, _ctx: Context, _height: u64) -> ProtocolRes...
  method get_latest_block (line 116) | async fn get_latest_block(&self, _ctx: Context) -> ProtocolResult<Block> {
  method set_latest_block (line 120) | async fn set_latest_block(&self, _ctx: Context, _block: Block) -> Protoc...
  method get_latest_block_header (line 124) | async fn get_latest_block_header(&self, _ctx: Context) -> ProtocolResult...
  method get_block_header (line 128) | async fn get_block_header(
  method insert_transactions (line 139) | async fn insert_transactions(
  method insert_receipts (line 148) | async fn insert_receipts(&self, _ctx: Context, _: u64, _: Vec<Receipt>) ...
  method update_latest_proof (line 152) | async fn update_latest_proof(&self, _ctx: Context, _: Proof) -> Protocol...
  method get_transaction_by_hash (line 156) | async fn get_transaction_by_hash(
  method get_transactions (line 164) | async fn get_transactions(
  method get_receipt_by_hash (line 173) | async fn get_receipt_by_hash(&self, _ctx: Context, _: Hash) -> ProtocolR...
  method get_receipts (line 177) | async fn get_receipts(
  method get_latest_proof (line 186) | async fn get_latest_proof(&self, _ctx: Context) -> ProtocolResult<Proof> {

FILE: built-in-services/multi-signature/src/lib.rs
  constant MULTI_SIG_SERVICE_NAME (line 25) | pub const MULTI_SIG_SERVICE_NAME: &str = "multi_signature";
  constant MAX_MULTI_SIGNATURE_RECURSION_DEPTH (line 26) | const MAX_MULTI_SIGNATURE_RECURSION_DEPTH: u8 = 8;
  constant MAX_PERMISSION_ACCOUNTS (line 27) | const MAX_PERMISSION_ACCOUNTS: u8 = 16;
  type MultiSignature (line 29) | pub trait MultiSignature {
    method verify_signature_ (line 30) | fn verify_signature_(
    method generate_account_ (line 36) | fn generate_account_(
    method verify_signature_ (line 48) | fn verify_signature_(
    method generate_account_ (line 56) | fn generate_account_(
  type MultiSignatureService (line 43) | pub struct MultiSignatureService<SDK> {
  function new (line 67) | pub fn new(sdk: SDK) -> Self {
  function init_genesis (line 72) | fn init_genesis(&mut self, payload: InitGenesisPayload) {
  function generate_account (line 112) | fn generate_account(
  function get_account_from_address (line 187) | fn get_account_from_address(
  function verify_signature (line 203) | pub fn verify_signature(
  function update_account (line 228) | fn update_account(
  function change_owner (line 309) | fn change_owner(
  function change_memo (line 339) | fn change_memo(
  function add_account (line 364) | fn add_account(
  function remove_account (line 400) | fn remove_account(
  function set_account_weight (line 431) | fn set_account_weight(
  function set_threshold (line 462) | fn set_threshold(
  function _inner_verify_signature (line 496) | fn _inner_verify_signature(&self, payload: VerifySignaturePayload) -> Se...
  function _verify_multi_signature (line 523) | fn _verify_multi_signature(
  function _verify_single_signature (line 570) | fn _verify_single_signature(
  function _is_recursion_depth_overflow (line 583) | fn _is_recursion_depth_overflow(&self, address: &Address, recursion_dept...
  type ServiceError (line 606) | pub enum ServiceError {
    method code (line 648) | fn code(&self) -> u64 {
  function from (line 668) | fn from(err: ServiceError) -> ServiceResponse<T> {
  function decode_list (line 673) | fn decode_list<T: Decodable>(bytes: &[u8], ty: &str) -> Result<Vec<T>, S...

FILE: built-in-services/multi-signature/src/tests/curd_test.rs
  function test_generate_multi_signature (line 12) | fn test_generate_multi_signature() {
  function test_set_threshold (line 80) | fn test_set_threshold() {
  function test_adeption_address (line 121) | fn test_adeption_address() {
  function test_add_account (line 150) | fn test_add_account() {
  function test_update_account (line 204) | fn test_update_account() {
  function test_set_weight (line 258) | fn test_set_weight() {
  function test_remove_account (line 313) | fn test_remove_account() {

FILE: built-in-services/multi-signature/src/tests/mod.rs
  type MockStorage (line 28) | struct MockStorage;
  method insert_block (line 32) | async fn insert_block(&self, _ctx: Context, _block: Block) -> ProtocolRe...
  method get_block (line 36) | async fn get_block(&self, _ctx: Context, _height: u64) -> ProtocolResult...
  method set_block (line 40) | async fn set_block(&self, _ctx: Context, _block: Block) -> ProtocolResul...
  method get_block_header (line 44) | async fn get_block_header(
  method remove_block (line 52) | async fn remove_block(&self, _ctx: Context, _height: u64) -> ProtocolRes...
  method get_latest_block (line 56) | async fn get_latest_block(&self, _ctx: Context) -> ProtocolResult<Block> {
  method set_latest_block (line 60) | async fn set_latest_block(&self, _ctx: Context, _block: Block) -> Protoc...
  method get_latest_block_header (line 64) | async fn get_latest_block_header(&self, _ctx: Context) -> ProtocolResult...
  method insert_transactions (line 71) | async fn insert_transactions(
  method insert_receipts (line 80) | async fn insert_receipts(&self, _ctx: Context, _: u64, _: Vec<Receipt>) ...
  method update_latest_proof (line 84) | async fn update_latest_proof(&self, _ctx: Context, _: Proof) -> Protocol...
  method get_transaction_by_hash (line 88) | async fn get_transaction_by_hash(
  method get_transactions (line 96) | async fn get_transactions(
  method get_receipt_by_hash (line 105) | async fn get_receipt_by_hash(&self, _ctx: Context, _: Hash) -> ProtocolR...
  method get_receipts (line 109) | async fn get_receipts(
  method get_latest_proof (line 118) | async fn get_latest_proof(&self, _ctx: Context) -> ProtocolResult<Proof> {
  function new_multi_signature_service (line 123) | fn new_multi_signature_service() -> MultiSignatureService<
  function mock_context (line 135) | fn mock_context(cycles_limit: u64, caller: Address) -> ServiceContext {
  function mock_hash (line 155) | fn mock_hash() -> Hash {
  function get_random_bytes (line 159) | fn get_random_bytes(len: usize) -> Bytes {
  function gen_one_keypair (line 164) | fn gen_one_keypair() -> (Bytes, Bytes) {
  function gen_keypairs (line 170) | fn gen_keypairs(num: usize) -> Vec<(Bytes, Bytes)> {
  function to_multi_sig_account (line 174) | fn to_multi_sig_account(pk: Bytes) -> AddressWithWeight {
  function sign (line 181) | fn sign(privkey: &Bytes, hash: &Hash) -> Bytes {
  function _gen_single_witness (line 188) | fn _gen_single_witness(privkey: &Bytes, hash: &Hash) -> VerifySignatureP...
  function to_accounts_list (line 203) | fn to_accounts_list(input: Vec<AddressWithWeight>) -> Vec<Account> {

FILE: built-in-services/multi-signature/src/tests/recursion_test.rs
  function test_recursion_verify_signature (line 8) | fn test_recursion_verify_signature() {
  function test_recursion_depth (line 83) | fn test_recursion_depth() {

FILE: built-in-services/multi-signature/src/types.rs
  type SetWeightResult (line 11) | pub enum SetWeightResult {
  type RemoveAccountResult (line 18) | pub enum RemoveAccountResult {
  type InitGenesisPayload (line 25) | pub struct InitGenesisPayload {
  type GenerateMultiSigAccountPayload (line 34) | pub struct GenerateMultiSigAccountPayload {
  type GenerateMultiSigAccountResponse (line 43) | pub struct GenerateMultiSigAccountResponse {
  type VerifySignaturePayload (line 48) | pub struct VerifySignaturePayload {
  type GetMultiSigAccountPayload (line 56) | pub struct GetMultiSigAccountPayload {
  type GetMultiSigAccountResponse (line 61) | pub struct GetMultiSigAccountResponse {
  type ChangeOwnerPayload (line 66) | pub struct ChangeOwnerPayload {
  type ChangeMemoPayload (line 72) | pub struct ChangeMemoPayload {
  type AddAccountPayload (line 78) | pub struct AddAccountPayload {
  type RemoveAccountPayload (line 84) | pub struct RemoveAccountPayload {
  type SetAccountWeightPayload (line 90) | pub struct SetAccountWeightPayload {
  type SetThresholdPayload (line 97) | pub struct SetThresholdPayload {
  type UpdateAccountPayload (line 103) | pub struct UpdateAccountPayload {
  type MultiSigPermission (line 112) | pub struct MultiSigPermission {
    method get_account (line 120) | pub fn get_account(&self, addr: &Address) -> Option<Account> {
    method set_owner (line 129) | pub fn set_owner(&mut self, new_owner: Address) {
    method set_memo (line 133) | pub fn set_memo(&mut self, new_memo: String) {
    method add_account (line 137) | pub fn add_account(&mut self, new_account: Account) {
    method remove_account (line 141) | pub fn remove_account(&mut self, address: &Address) -> RemoveAccountRe...
    method set_threshold (line 168) | pub fn set_threshold(&mut self, new_threshold: u32) {
    method set_account_weight (line 172) | pub fn set_account_weight(
  type Account (line 198) | pub struct Account {
  type AddressWithWeight (line 205) | pub struct AddressWithWeight {
    method into_signle_account (line 237) | pub fn into_signle_account(self) -> Account {
  type Witness (line 211) | pub struct Witness {
    method new (line 217) | pub fn new(pubkeys: Vec<Bytes>, signatures: Vec<Bytes>) -> Self {
    method into_addr_map (line 224) | pub fn into_addr_map(self) -> HashMap<Address, (Bytes, Bytes)> {

FILE: built-in-services/util/src/lib.rs
  constant UTIL_SERVICE_NAME (line 15) | pub const UTIL_SERVICE_NAME: &str = "util";
  type UtilService (line 17) | pub struct UtilService<SDK> {
  function new (line 23) | pub fn new(_sdk: SDK) -> Self {
  function keccak256 (line 29) | fn keccak256(
  function verify (line 49) | fn verify(

FILE: built-in-services/util/src/tests/mod.rs
  function test_hash (line 26) | fn test_hash() {
  function test_verify (line 46) | fn test_verify() {
  function new_util_service (line 85) | fn new_util_service(
  function mock_context (line 97) | fn mock_context(cycles_limit: u64, caller: Address) -> ServiceContext {
  type MockStorage (line 117) | struct MockStorage;
  method insert_block (line 121) | async fn insert_block(&self, _ctx: Context, _block: Block) -> ProtocolRe...
  method get_block (line 125) | async fn get_block(&self, _ctx: Context, _height: u64) -> ProtocolResult...
  method get_block_header (line 129) | async fn get_block_header(
  method set_block (line 137) | async fn set_block(&self, _ctx: Context, _block: Block) -> ProtocolResul...
  method remove_block (line 141) | async fn remove_block(&self, _ctx: Context, _height: u64) -> ProtocolRes...
  method get_latest_block (line 145) | async fn get_latest_block(&self, _ctx: Context) -> ProtocolResult<Block> {
  method set_latest_block (line 149) | async fn set_latest_block(&self, _ctx: Context, _block: Block) -> Protoc...
  method get_latest_block_header (line 153) | async fn get_latest_block_header(&self, _ctx: Context) -> ProtocolResult...
  method insert_transactions (line 160) | async fn insert_transactions(
  method get_transactions (line 169) | async fn get_transactions(
  method get_transaction_by_hash (line 178) | async fn get_transaction_by_hash(
  method insert_receipts (line 186) | async fn insert_receipts(
  method get_receipt_by_hash (line 195) | async fn get_receipt_by_hash(&self, _: Context, _: Hash) -> ProtocolResu...
  method get_receipts (line 199) | async fn get_receipts(
  method update_latest_proof (line 208) | async fn update_latest_proof(&self, _: Context, _: Proof) -> ProtocolRes...
  method get_latest_proof (line 212) | async fn get_latest_proof(&self, _: Context) -> ProtocolResult<Proof> {

FILE: built-in-services/util/src/types.rs
  type KeccakPayload (line 5) | pub struct KeccakPayload {
  type KeccakResponse (line 10) | pub struct KeccakResponse {
  type SigVerifyPayload (line 15) | pub struct SigVerifyPayload {
  type SigVerifyResponse (line 22) | pub struct SigVerifyResponse {

FILE: byzantine/src/behaviors.rs
  type Behavior (line 13) | pub struct Behavior {
  type Request (line 23) | pub enum Request {
    method to_end (line 34) | pub fn to_end(&self) -> &str {
  type MessageType (line 49) | pub enum MessageType {
  type NewTx (line 65) | pub enum NewTx {
  type PullTxs (line 81) | pub enum PullTxs {
  type NewProposal (line 90) | pub enum NewProposal {
  type NewVote (line 119) | pub enum NewVote {
  type NewQC (line 129) | pub enum NewQC {
  type NewChoke (line 139) | pub enum NewChoke {
  type SyncPullBlock (line 149) | pub enum SyncPullBlock {

FILE: byzantine/src/commander.rs
  type Commander (line 18) | pub struct Commander {
    method new (line 26) | pub fn new(
    method run (line 40) | pub async fn run(mut self) {
  function add_primitive_generator (line 68) | fn add_primitive_generator(list: &mut Vec<BehaviorGenerator>) {

FILE: byzantine/src/config.rs
  type ConfigGraphQL (line 13) | pub struct ConfigGraphQL {
  type ConfigGraphQLTLS (line 27) | pub struct ConfigGraphQLTLS {
  type ConfigNetwork (line 33) | pub struct ConfigNetwork {
  type ConfigNetworkBootstrap (line 56) | pub struct ConfigNetworkBootstrap {
  type ConfigConsensus (line 62) | pub struct ConfigConsensus {
  method default (line 67) | fn default() -> Self {
  function default_broadcast_txs_size (line 74) | fn default_broadcast_txs_size() -> usize {
  function default_broadcast_txs_interval (line 78) | fn default_broadcast_txs_interval() -> u64 {
  type ConfigMempool (line 83) | pub struct ConfigMempool {
  type ConfigExecutor (line 93) | pub struct ConfigExecutor {
  type ConfigRocksDB (line 99) | pub struct ConfigRocksDB {
  method default (line 104) | fn default() -> Self {
  type ConfigLogger (line 110) | pub struct ConfigLogger {
  method default (line 122) | fn default() -> Self {
  type ConfigAPM (line 136) | pub struct ConfigAPM {
  type Config (line 143) | pub struct Config {
    method data_path_for_state (line 163) | pub fn data_path_for_state(&self) -> PathBuf {
    method data_path_for_block (line 170) | pub fn data_path_for_block(&self) -> PathBuf {
    method data_path_for_txs_wal (line 177) | pub fn data_path_for_txs_wal(&self) -> PathBuf {
  type Generators (line 185) | pub struct Generators {

FILE: byzantine/src/default_start.rs
  function start (line 34) | pub async fn start(config: Config, genesis: Genesis, generators: Generat...

FILE: byzantine/src/invalid_types.rs
  type InvalidStruct (line 29) | pub struct InvalidStruct {
    method gen (line 34) | pub fn gen(len: usize) -> Self {
  method encode (line 42) | fn encode(&mut self) -> ProtocolResult<Bytes> {
  method decode (line 46) | fn decode(bytes: Bytes) -> ProtocolResult<Self> {
  method encode (line 52) | fn encode(&self) -> Result<Bytes, Box<dyn Error + Send>> {
  method decode (line 57) | fn decode(data: Bytes) -> Result<Self, Box<dyn Error + Send>> {
  function gen_invalid_struct_new_choke (line 65) | pub fn gen_invalid_struct_new_choke(
  function gen_invalid_height_new_choke (line 73) | pub fn gen_invalid_height_new_choke(
  function gen_invalid_round_new_choke (line 84) | pub fn gen_invalid_round_new_choke(
  function gen_invalid_from_new_vote (line 95) | pub fn gen_invalid_from_new_vote(
  function gen_invalid_sig_new_choke (line 106) | pub fn gen_invalid_sig_new_choke(
  function gen_invalid_address_new_choke (line 117) | pub fn gen_invalid_address_new_choke(
  function gen_invalid_struct_new_qc (line 131) | pub fn gen_invalid_struct_new_qc(_state: &State, _my_pub_key: &Bytes) ->...
  function gen_invalid_height_new_qc (line 135) | pub fn gen_invalid_height_new_qc(state: &State, my_pub_key: &Bytes) -> V...
  function gen_invalid_round_new_qc (line 141) | pub fn gen_invalid_round_new_qc(state: &State, my_pub_key: &Bytes) -> Ve...
  function gen_invalid_block_hash_new_qc (line 147) | pub fn gen_invalid_block_hash_new_qc(state: &State, my_pub_key: &Bytes) ...
  function gen_invalid_sig_new_qc (line 153) | pub fn gen_invalid_sig_new_qc(state: &State, my_pub_key: &Bytes) -> Vec<...
  function gen_invalid_leader_new_qc (line 159) | pub fn gen_invalid_leader_new_qc(state: &State, my_pub_key: &Bytes) -> V...
  function gen_invalid_struct_new_vote (line 168) | pub fn gen_invalid_struct_new_vote(
  function gen_invalid_height_new_vote (line 176) | pub fn gen_invalid_height_new_vote(
  function gen_invalid_round_new_vote (line 187) | pub fn gen_invalid_round_new_vote(
  function gen_invalid_block_hash_new_vote (line 198) | pub fn gen_invalid_block_hash_new_vote(
  function gen_invalid_sig_new_vote (line 209) | pub fn gen_invalid_sig_new_vote(
  function gen_invalid_voter_new_vote (line 220) | pub fn gen_invalid_voter_new_vote(
  function gen_valid_new_proposal (line 234) | pub fn gen_valid_new_proposal(
  function gen_invalid_prop_proposer_new_proposal (line 258) | pub fn gen_invalid_prop_proposer_new_proposal(
  function gen_invalid_lock_new_proposal (line 274) | pub fn gen_invalid_lock_new_proposal(
  function gen_invalid_block_hash_new_proposal (line 290) | pub fn gen_invalid_block_hash_new_proposal(
  function gen_invalid_content_struct_new_proposal (line 306) | pub fn gen_invalid_content_struct_new_proposal(
  function gen_invalid_round_new_proposal (line 326) | pub fn gen_invalid_round_new_proposal(
  function gen_invalid_prop_height_new_proposal (line 342) | pub fn gen_invalid_prop_height_new_proposal(
  function gen_invalid_sig_new_proposal (line 358) | pub fn gen_invalid_sig_new_proposal(
  function gen_invalid_tx_hash_new_proposal (line 376) | pub fn gen_invalid_tx_hash_new_proposal(
  function gen_invalid_validators_new_proposal (line 404) | pub fn gen_invalid_validators_new_proposal(
  function gen_invalid_version_new_proposal (line 417) | pub fn gen_invalid_version_new_proposal(
  function gen_invalid_proof_new_proposal (line 430) | pub fn gen_invalid_proof_new_proposal(
  function gen_invalid_block_proposer_new_proposal (line 443) | pub fn gen_invalid_block_proposer_new_proposal(
  function gen_invalid_cycle_used_new_proposal (line 456) | pub fn gen_invalid_cycle_used_new_proposal(
  function gen_invalid_receipt_root_new_proposal (line 469) | pub fn gen_invalid_receipt_root_new_proposal(
  function gen_invalid_state_root_new_proposal (line 482) | pub fn gen_invalid_state_root_new_proposal(
  function gen_invalid_confirm_root_new_proposal (line 495) | pub fn gen_invalid_confirm_root_new_proposal(
  function gen_invalid_signed_tx_hash_new_proposal (line 508) | pub fn gen_invalid_signed_tx_hash_new_proposal(
  function gen_invalid_order_root_new_proposal (line 521) | pub fn gen_invalid_order_root_new_proposal(
  function gen_invalid_timestamp_new_proposal (line 534) | pub fn gen_invalid_timestamp_new_proposal(
  function gen_invalid_exec_height_new_proposal (line 547) | pub fn gen_invalid_exec_height_new_proposal(
  function gen_invalid_height_new_proposal (line 560) | pub fn gen_invalid_height_new_proposal(
  function gen_invalid_prev_hash_new_proposal (line 573) | pub fn gen_invalid_prev_hash_new_proposal(
  function gen_invalid_chain_id_new_proposal (line 586) | pub fn gen_invalid_chain_id_new_proposal(
  function gen_invalid_struct_new_proposal (line 599) | pub fn gen_invalid_struct_new_proposal(
  function gen_invalid_height_pull_txs (line 613) | pub fn gen_invalid_height_pull_txs(height: u64) -> MsgPullTxs {
  function gen_invalid_hash_pull_txs (line 622) | pub fn gen_invalid_hash_pull_txs(_height: u64) -> MsgPullTxs {
  function gen_not_exists_txs_pull_txs (line 631) | pub fn gen_not_exists_txs_pull_txs(_height: u64) -> MsgPullTxs {
  function gen_invalid_hash_signed_tx (line 643) | pub fn gen_invalid_hash_signed_tx(
  function gen_invalid_sig_signed_tx (line 652) | pub fn gen_invalid_sig_signed_tx(
  function gen_invalid_chain_id_signed_tx (line 661) | pub fn gen_invalid_chain_id_signed_tx(
  function gen_invalid_cycles_price_signed_tx (line 671) | pub fn gen_invalid_cycles_price_signed_tx(
  function gen_invalid_cycles_limit_signed_tx (line 681) | pub fn gen_invalid_cycles_limit_signed_tx(
  function gen_invalid_nonce_of_rand_len_signed_tx (line 691) | pub fn gen_invalid_nonce_of_rand_len_signed_tx(
  function gen_invalid_nonce_dup_signed_tx (line 701) | pub fn gen_invalid_nonce_dup_signed_tx(
  function gen_invalid_request_signed_tx (line 712) | pub fn gen_invalid_request_signed_tx(
  function gen_invalid_timeout_signed_tx (line 722) | pub fn gen_invalid_timeout_signed_tx(
  function gen_invalid_sender_signed_tx (line 732) | pub fn gen_invalid_sender_signed_tx(
  function gen_valid_tx (line 742) | pub fn gen_valid_tx(

FILE: byzantine/src/message.rs
  type NewTxsHandler (line 12) | pub struct NewTxsHandler {
  type Message (line 18) | type Message = MsgNewTxs;
  method process (line 20) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type PullTxsHandler (line 30) | pub struct PullTxsHandler {
  type Message (line 36) | type Message = MsgPullTxs;
  method process (line 38) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type ProposalMessageHandler (line 48) | pub struct ProposalMessageHandler {
  type Message (line 54) | type Message = Proposal;
  method process (line 57) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type VoteMessageHandler (line 67) | pub struct VoteMessageHandler {
  type Message (line 73) | type Message = Vote;
  method process (line 76) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type QCMessageHandler (line 86) | pub struct QCMessageHandler {
  type Message (line 92) | type Message = QC;
  method process (line 95) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type ChokeMessageHandler (line 105) | pub struct ChokeMessageHandler {
  type Message (line 111) | type Message = Choke;
  method process (line 114) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type RemoteHeightMessageHandler (line 124) | pub struct RemoteHeightMessageHandler {
  type Message (line 130) | type Message = u64;
  method process (line 133) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...

FILE: byzantine/src/strategy.rs
  type Strategy (line 11) | pub trait Strategy {
    method get_behaviors (line 12) | fn get_behaviors(&self, request: Option<Request>) -> Vec<Behavior>;
    method get_behaviors (line 49) | fn get_behaviors(&self, request: Option<Request>) -> Vec<Behavior> {
  type BehaviorGenerator (line 16) | pub struct BehaviorGenerator {
    method gen_behavior (line 25) | fn gen_behavior(
  type DefaultStrategy (line 43) | pub struct DefaultStrategy {
  function gen_rand_pub_key_list (line 67) | pub fn gen_rand_pub_key_list(pub_key_list: &mut Vec<Bytes>) -> Vec<Bytes> {

FILE: byzantine/src/utils.rs
  constant VALIDATOR_VERSION (line 32) | const VALIDATOR_VERSION: u64 = 0;
  constant HASH_LEN (line 33) | const HASH_LEN: u64 = 32;
  constant ADDRESS_LEN (line 34) | const ADDRESS_LEN: u64 = 20;
  constant SIGNATURE_LEN (line 35) | const SIGNATURE_LEN: u64 = 192;
  constant BITMAP_LEN (line 36) | const BITMAP_LEN: u64 = 1;
  function time_now (line 38) | pub fn time_now() -> u64 {
  function gen_random_bytes (line 45) | pub fn gen_random_bytes(len: usize) -> Bytes {
  function gen_random_string (line 50) | pub fn gen_random_string(len: usize) -> String {
  function gen_range (line 57) | pub fn gen_range<T: SampleUniform, B1, B2>(low: B1, high: B2) -> T
  function gen_bool (line 66) | pub fn gen_bool(p: f64) -> bool {
  function gen_valid_raw_tx (line 75) | pub fn gen_valid_raw_tx(
  function gen_invalid_request (line 91) | pub fn gen_invalid_request() -> TransactionRequest {
  function gen_transfer_tx_request (line 99) | pub fn gen_transfer_tx_request() -> TransactionRequest {
  function gen_address_bytes (line 107) | pub fn gen_address_bytes(pri_key: &Secp256k1PrivateKey) -> Address {
  function gen_valid_hash (line 112) | pub fn gen_valid_hash() -> Hash {
  function gen_invalid_hash (line 116) | pub fn gen_invalid_hash() -> Hash {
  function gen_invalid_address (line 121) | pub fn gen_invalid_address() -> Address {
  function gen_valid_signed_tx (line 126) | pub fn gen_valid_signed_tx(
  function gen_signed_tx (line 133) | pub fn gen_signed_tx(
  function gen_valid_block_header (line 155) | pub fn gen_valid_block_header(
  function gen_valid_block (line 182) | pub fn gen_valid_block(header: BlockHeader, ordered_tx_hashes: Vec<Hash>...
  function gen_invalid_content_struct_proposal (line 189) | pub fn gen_invalid_content_struct_proposal(
  function gen_valid_proposal (line 205) | pub fn gen_valid_proposal(
  function gen_valid_signed_proposal (line 235) | pub fn gen_valid_signed_proposal(
  function gen_signed_proposal_from_header (line 249) | pub fn gen_signed_proposal_from_header(
  function gen_invalid_chain_id (line 261) | pub fn gen_invalid_chain_id() -> Hash {
  function gen_positive_range (line 265) | pub fn gen_positive_range(base: u64, range: u64) -> u64 {
  function gen_invalid_sig (line 275) | pub fn gen_invalid_sig() -> Bytes {
  function gen_invalid_proof (line 279) | pub fn gen_invalid_proof() -> Proof {
  function gen_invalid_bitmap (line 289) | pub fn gen_invalid_bitmap() -> Bytes {
  function gen_invalid_validators (line 293) | pub fn gen_invalid_validators() -> Vec<Validator> {
  function gen_invalid_lock (line 303) | pub fn gen_invalid_lock() -> PoLC {
  function gen_invalid_qc (line 310) | pub fn gen_invalid_qc() -> AggregatedVote {
  function gen_invalid_aggregate_sig (line 321) | pub fn gen_invalid_aggregate_sig() -> AggregatedSignature {
  function gen_valid_qc (line 328) | pub fn gen_valid_qc(state: &State, my_pub_key: &Bytes) -> AggregatedVote {
  function gen_valid_aggregate_sig (line 339) | pub fn gen_valid_aggregate_sig() -> AggregatedSignature {
  function gen_valid_signed_vote (line 346) | pub fn gen_valid_signed_vote(
  function gen_valid_vote (line 362) | pub fn gen_valid_vote(state: &State) -> Vote {
  function gen_valid_choke (line 371) | pub fn gen_valid_choke(state: &State, my_pub_key: &Bytes) -> Choke {
  function gen_invalid_from (line 379) | pub fn gen_invalid_from() -> UpdateFrom {
  function gen_valid_signed_choke (line 388) | pub fn gen_valid_signed_choke(
  type HashChoke (line 404) | struct HashChoke {
  method rlp_append (line 410) | fn rlp_append(&self, s: &mut RlpStream) {
  function choke_to_hash (line 415) | fn choke_to_hash(choke: &Choke) -> HashChoke {
  function gen_invalid_aggregated_choke (line 422) | pub fn gen_invalid_aggregated_choke() -> AggregatedChoke {
  function gen_vote_type (line 431) | fn gen_vote_type() -> VoteType {

FILE: byzantine/src/worker.rs
  type State (line 212) | pub struct State {
  method default (line 227) | fn default() -> Self {
  type Worker (line 250) | pub struct Worker<N: Rpc + PeerTrust + Gossip + 'static> {
  function new (line 266) | pub fn new(
  function run (line 287) | pub async fn run(mut self) {
  function process (line 302) | pub async fn process(&mut self, ctx: Context, behavior: &Behavior) {
  function send_invalid_new_height (line 517) | pub async fn send_invalid_new_height(&mut self, ctx: Context, behavior: ...
  function send_invalid_struct_of_pull_txs (line 531) | pub async fn send_invalid_struct_of_pull_txs(&mut self, ctx: Context, be...
  function send_invalid_struct_of_new_tx (line 549) | pub async fn send_invalid_struct_of_new_tx(&self, ctx: Context, behavior...
  function send_invalid_struct_of_push_txs (line 562) | pub async fn send_invalid_struct_of_push_txs(&self, ctx: Context, behavi...
  function send_invalid_nonce_dup_of_new_tx (line 582) | pub async fn send_invalid_nonce_dup_of_new_tx(&self, ctx: Context, behav...
  function set_state (line 599) | async fn set_state(&mut self, req_opt: Option<&Request>) {
  function check_liveness (line 683) | fn check_liveness(&self) {
  function send_prevote (line 695) | async fn send_prevote(&self, proposal: &Proposal<FixedPill>) {
  function send_choke (line 719) | async fn send_choke(&self, choke: Choke, sender: Bytes) {
  function send (line 736) | async fn send<M, N>(network: &Arc<N>, message: M, ctx: Context, end: &st...

FILE: byzantine/tests/byz.test.ts
  function sleep (line 44) | function sleep(ms: number) {
  function get_client (line 48) | function get_client(file_path: string, chain_id: string) {

FILE: common/apm/src/metrics.rs
  type Error (line 23) | enum Error {
    method from (line 29) | fn from(err: prometheus::Error) -> Error {
  method from (line 35) | fn from(err: Error) -> ProtocolError {
  function duration_to_sec (line 42) | pub fn duration_to_sec(d: Duration) -> f64 {
  function all_metrics (line 46) | pub fn all_metrics() -> ProtocolResult<Vec<u8>> {
  function test_duration_to_sec (line 64) | fn test_duration_to_sec() {

FILE: common/apm/src/metrics/network.rs
  function on_network_message (line 147) | fn on_network_message(direction: &str, target: &str, url: &str, inc: i64) {
  function on_network_message_sent_all_target (line 162) | pub fn on_network_message_sent_all_target(url: &str) {
  function on_network_message_sent_multi_target (line 166) | pub fn on_network_message_sent_multi_target(url: &str, target_count: i64) {
  function on_network_message_sent (line 170) | pub fn on_network_message_sent(url: &str) {
  function on_network_message_received (line 174) | pub fn on_network_message_received(url: &str) {

FILE: common/apm/src/metrics/storage.rs
  function on_storage_get_state (line 77) | pub fn on_storage_get_state(duration: Duration, keys: i64) {
  function on_storage_put_state (line 84) | pub fn on_storage_put_state(duration: Duration, size: i64) {
  function on_storage_get_cf (line 91) | pub fn on_storage_get_cf(sc: StorageCategory, duration: Duration, keys: ...
  function on_storage_put_cf (line 122) | pub fn on_storage_put_cf(sc: StorageCategory, duration: Duration, size: ...

FILE: common/channel/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: common/config-parser/src/lib.rs
  function parse_reader (line 12) | pub fn parse_reader<R: io::Read, T: de::DeserializeOwned>(r: &mut R) -> ...
  function parse_file (line 21) | pub fn parse_file<T: de::DeserializeOwned>(name: impl AsRef<Path>) -> Re...
  function parse_http (line 30) | pub fn parse_http<T: de::DeserializeOwned>(name: &str) -> Result<T, Pars...
  function parse (line 37) | pub fn parse<T: de::DeserializeOwned>(name: &str) -> Result<T, ParseErro...
  type ParseError (line 46) | pub enum ParseError {
    method fmt (line 55) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method from (line 65) | fn from(error: io::Error) -> ParseError {
    method from (line 71) | fn from(error: toml::de::Error) -> ParseError {
    method from (line 77) | fn from(error: reqwest::Error) -> ParseError {
  type Config (line 89) | struct Config {
  function test_parse_reader (line 95) | fn test_parse_reader() {
  function test_parse_file (line 108) | fn test_parse_file() {
  function test_parse_http (line 116) | fn test_parse_http() {
  function test_parse (line 124) | fn test_parse() {

FILE: common/config-parser/src/types.rs
  type ConfigGraphQL (line 12) | pub struct ConfigGraphQL {
  type ConfigGraphQLTLS (line 27) | pub struct ConfigGraphQLTLS {
  type ConfigNetwork (line 33) | pub struct ConfigNetwork {
  type ConfigNetworkBootstrap (line 56) | pub struct ConfigNetworkBootstrap {
  function default_overlord_gap (line 61) | fn default_overlord_gap() -> usize {
  function default_sync_txs_chunk_size (line 65) | fn default_sync_txs_chunk_size() -> usize {
  type ConfigConsensus (line 70) | pub struct ConfigConsensus {
  function default_broadcast_txs_size (line 77) | fn default_broadcast_txs_size() -> usize {
  function default_broadcast_txs_interval (line 81) | fn default_broadcast_txs_interval() -> u64 {
  type ConfigMempool (line 86) | pub struct ConfigMempool {
  type ConfigExecutor (line 96) | pub struct ConfigExecutor {
  type ConfigRocksDB (line 102) | pub struct ConfigRocksDB {
  method default (line 107) | fn default() -> Self {
  type ConfigLogger (line 113) | pub struct ConfigLogger {
  method default (line 126) | fn default() -> Self {
  type ConfigAPM (line 141) | pub struct ConfigAPM {
  type Config (line 148) | pub struct Config {
    method data_path_for_state (line 167) | pub fn data_path_for_state(&self) -> PathBuf {
    method data_path_for_block (line 174) | pub fn data_path_for_block(&self) -> PathBuf {
    method data_path_for_txs_wal (line 181) | pub fn data_path_for_txs_wal(&self) -> PathBuf {
    method data_path_for_consensus_wal (line 187) | pub fn data_path_for_consensus_wal(&self) -> PathBuf {

FILE: common/crypto/src/lib.rs
  function gen_common_ref (line 42) | fn gen_common_ref() -> String {
  function mock_block_hash (line 49) | fn mock_block_hash() -> Hash {
  function mock_vote (line 54) | fn mock_vote() -> Vote {
  function gen_key_pair_sigs (line 63) | fn gen_key_pair_sigs(
  function bench_4_aggregated_sig (line 88) | fn bench_4_aggregated_sig(b: &mut Bencher) {
  function bench_8_aggregated_sig (line 120) | fn bench_8_aggregated_sig(b: &mut Bencher) {
  function bench_16_aggregated_sig (line 152) | fn bench_16_aggregated_sig(b: &mut Bencher) {
  function bench_32_aggregated_sig (line 184) | fn bench_32_aggregated_sig(b: &mut Bencher) {
  function bench_64_aggregated_sig (line 216) | fn bench_64_aggregated_sig(b: &mut Bencher) {
  function bench_4_aggregated_sig_verify (line 248) | fn bench_4_aggregated_sig_verify(b: &mut Bencher) {
  function bench_8_aggregated_sig_verify (line 289) | fn bench_8_aggregated_sig_verify(b: &mut Bencher) {
  function bench_16_aggregated_sig_verify (line 330) | fn bench_16_aggregated_sig_verify(b: &mut Bencher) {
  function bench_32_aggregated_sig_verify (line 371) | fn bench_32_aggregated_sig_verify(b: &mut Bencher) {
  function bench_64_aggregated_sig_verify (line 412) | fn bench_64_aggregated_sig_verify(b: &mut Bencher) {

FILE: common/logger/src/date_fixed_roller.rs
  type DateFixedWindowRollerConfig (line 11) | pub struct DateFixedWindowRollerConfig {
  type DateFixedWindowRollerBuilder (line 15) | pub struct DateFixedWindowRollerBuilder;
    method build (line 18) | pub fn build(
  type DateFixedWindowRoller (line 42) | pub struct DateFixedWindowRoller {
    method builder (line 47) | pub fn builder() -> DateFixedWindowRollerBuilder {
    method roll_file (line 51) | fn roll_file(
  method roll (line 80) | fn roll(&self, cur_log: &Path) -> Result<(), Box<dyn Error + Sync + Send...
  type DateFixedWindowRollerDeserializer (line 90) | pub struct DateFixedWindowRollerDeserializer;
  type Config (line 93) | type Config = DateFixedWindowRollerConfig;
  type Trait (line 94) | type Trait = dyn Roll;
  method deserialize (line 96) | fn deserialize(
  function test_rotation (line 119) | fn test_rotation() {

FILE: common/logger/src/lib.rs
  function init (line 40) | pub fn init<S: ::std::hash::BuildHasher>(
  function convert_level (line 141) | fn convert_level(level: &str) -> LevelFilter {
  function metrics (line 156) | pub fn metrics(name: &str, mut content: JsonValue) {
  function log (line 166) | pub fn log(level: Level, module: &str, event: &str, ctx: &Context, mut m...
  type TraceContext (line 179) | struct TraceContext {
  function trace_context (line 186) | fn trace_context(ctx: &Context) -> Option<TraceContext> {
  function test_json (line 206) | fn test_json() {

FILE: common/merkle/src/lib.rs
  type ProofNode (line 8) | pub struct ProofNode {
  type Merkle (line 13) | pub struct Merkle {
    method from_hashes (line 18) | pub fn from_hashes(hashes: Vec<Hash>) -> Self {
    method get_root_hash (line 23) | pub fn get_root_hash(&self) -> Option<Hash> {
    method get_proof_by_input_index (line 30) | pub fn get_proof_by_input_index(&self, input_index: usize) -> Option<V...
  function merge (line 46) | fn merge(left: &Hash, right: &Hash) -> Hash {
  function mock_hash (line 73) | fn mock_hash() -> Hash {
  function rand_hashes (line 79) | fn rand_hashes(size: usize) -> Vec<Hash> {
  function bench_merkle_1000_hashes (line 84) | fn bench_merkle_1000_hashes(b: &mut Bencher) {
  function bench_merkle_2000_hashes (line 93) | fn bench_merkle_2000_hashes(b: &mut Bencher) {
  function bench_merkle_4000_hashes (line 102) | fn bench_merkle_4000_hashes(b: &mut Bencher) {
  function bench_merkle_8000_hashes (line 111) | fn bench_merkle_8000_hashes(b: &mut Bencher) {
  function bench_merkle_16000_hashes (line 120) | fn bench_merkle_16000_hashes(b: &mut Bencher) {

FILE: common/pubsub/src/lib.rs
  function it_works (line 4) | fn it_works() {

FILE: core/api/src/adapter/mod.rs
  type APIError (line 17) | pub enum APIError {
  method from (line 32) | fn from(api_err: APIError) -> ProtocolError {
  type DefaultAPIAdapter (line 37) | pub struct DefaultAPIAdapter<EF, M, S, DB, Mapping> {
  function new (line 54) | pub fn new(
  method insert_signed_txs (line 79) | async fn insert_signed_txs(
  method get_block_by_height (line 87) | async fn get_block_by_height(
  method get_block_header_by_height (line 98) | async fn get_block_header_by_height(
  method get_receipt_by_tx_hash (line 109) | async fn get_receipt_by_tx_hash(
  method get_transaction_by_hash (line 134) | async fn get_transaction_by_hash(
  method query_service (line 142) | async fn query_service(

FILE: core/api/src/config.rs
  type GraphQLConfig (line 5) | pub struct GraphQLConfig {
  type GraphQLTLS (line 29) | pub struct GraphQLTLS {
  method default (line 35) | fn default() -> Self {

FILE: core/api/src/lib.rs
  type State (line 36) | struct State {
  type Query (line 45) | struct Query;
    method get_block (line 50) | async fn get_block(state_ctx: &State, height: Option<Uint64>) -> Field...
    method get_transaction (line 100) | async fn get_transaction(
    method get_receipt (line 120) | async fn get_receipt(state_ctx: &State, tx_hash: Hash) -> FieldResult<...
    method query_service (line 134) | async fn query_service(
  type Mutation (line 184) | struct Mutation;
    method send_transaction (line 189) | async fn send_transaction(
    method unsafe_send_transaction (line 227) | async fn unsafe_send_transaction(
  type Schema (line 259) | type Schema = juniper::RootNode<'static, Query, Mutation>;
  function graphiql (line 261) | async fn graphiql() -> HttpResponse {
  function graphql (line 267) | async fn graphql(
  function metrics (line 279) | async fn metrics() -> HttpResponse {
  type ProfileReport (line 300) | pub enum ProfileReport {
  type Err (line 308) | type Err = &'static str;
  method from_str (line 310) | fn from_str(report: &str) -> Result<Self, Self::Err> {
  type ProfileConfig (line 319) | pub struct ProfileConfig {
  method default (line 326) | fn default() -> Self {
  type Config (line 336) | type Config = ();
  type Error (line 337) | type Error = actix_web::Error;
  type Future (line 338) | type Future = future::Ready<Result<Self, Self::Error>>;
  method from_request (line 340) | fn from_request(req: &HttpRequest, _: &mut dev::Payload) -> Self::Future {
  function dump_profile (line 371) | pub async fn dump_profile(maybe_config: actix_web::Result<ProfileConfig>...
  function start_graphql (line 410) | pub async fn start_graphql<Adapter: APIAdapter + 'static>(cfg: GraphQLCo...

FILE: core/api/src/schema/block.rs
  type Block (line 13) | pub struct Block {
    method from (line 114) | fn from(block: protocol::types::Block) -> Self {
  type BlockHeader (line 24) | pub struct BlockHeader {
    method from (line 76) | fn from(block_header: protocol::types::BlockHeader) -> Self {
  type Proof (line 59) | pub struct Proof {
    method from (line 131) | fn from(proof: protocol::types::Proof) -> Self {
  type Validator (line 69) | pub struct Validator {
    method from (line 143) | fn from(validator: protocol::types::Validator) -> Self {

FILE: core/api/src/schema/mod.rs
  type ServiceResponse (line 20) | pub struct ServiceResponse {
    method from (line 27) | fn from(resp: protocol::traits::ServiceResponse<String>) -> Self {
  type Hash (line 38) | pub struct Hash(String);
    method as_hex (line 54) | pub fn as_hex(&self) -> String {
    method from (line 88) | fn from(hash: protocol::types::Hash) -> Self {
  type MerkleRoot (line 39) | pub type MerkleRoot = Hash;
  type Address (line 43) | pub struct Address(String);
    method to_str (line 60) | pub fn to_str(&self) -> &str {
    method from (line 94) | fn from(address: protocol::types::Address) -> Self {
  type Uint64 (line 47) | pub struct Uint64(String);
    method as_hex (line 66) | pub fn as_hex(&self) -> ProtocolResult<String> {
    method try_into_u64 (line 70) | pub fn try_into_u64(self) -> ProtocolResult<u64> {
    method from (line 100) | fn from(n: u64) -> Self {
  type Bytes (line 51) | pub struct Bytes(String);
    method as_hex (line 77) | pub fn as_hex(&self) -> ProtocolResult<String> {
    method to_vec (line 81) | pub fn to_vec(&self) -> ProtocolResult<Vec<u8>> {
    method from (line 106) | fn from(bytes: protocol::Bytes) -> Self {
  function clean_0x (line 111) | fn clean_0x(s: &str) -> ProtocolResult<String> {
  type SchemaError (line 120) | pub enum SchemaError {
  method from (line 134) | fn from(err: SchemaError) -> ProtocolError {

FILE: core/api/src/schema/receipt.rs
  type Receipt (line 4) | pub struct Receipt {
    method from (line 28) | fn from(receipt: protocol::types::Receipt) -> Self {
  type Event (line 14) | pub struct Event {
    method from (line 41) | fn from(event: protocol::types::Event) -> Self {
  type ReceiptResponse (line 21) | pub struct ReceiptResponse {
    method from (line 51) | fn from(response: protocol::types::ReceiptResponse) -> Self {

FILE: core/api/src/schema/transaction.rs
  type SignedTransaction (line 6) | pub struct SignedTransaction {
    method from (line 22) | fn from(stx: protocol::types::SignedTransaction) -> Self {
  type InputRawTransaction (line 49) | pub struct InputRawTransaction {
  type InputTransactionEncryption (line 76) | pub struct InputTransactionEncryption {
  function to_signed_transaction (line 85) | pub fn to_signed_transaction(
  function to_transaction (line 101) | pub fn to_transaction(raw: InputRawTransaction) -> ProtocolResult<protoc...

FILE: core/cli/src/error.rs
  type CliError (line 8) | pub enum CliError {
  method from (line 40) | fn from(err: CliError) -> ProtocolError {

FILE: core/cli/src/lib.rs
  constant PLEASE_CONFIRM (line 24) | const PLEASE_CONFIRM: &str =
  type CliConfig (line 27) | pub struct CliConfig {
  type Cli (line 35) | pub struct Cli<'a, Mapping>
  function run (line 49) | pub fn run(
  function new (line 60) | pub fn new(
  function register_log (line 95) | fn register_log(config: &Config) {
  function start (line 108) | pub fn start(self) -> ProtocolResult<()> {
  function generate_matches (line 155) | pub fn generate_matches(cli_config: CliConfig, cmds: Option<Vec<&str>>) ...
  function generate_maintenance_cli (line 263) | fn generate_maintenance_cli(self) -> MaintenanceCli<'a, Mapping, ImplSto...
  type MaintenanceCli (line 304) | pub struct MaintenanceCli<'a, Mapping, S>
  function new (line 322) | pub fn new(
  function start (line 340) | pub fn start(&self) -> ProtocolResult<()> {
  function latest_block (line 350) | pub fn latest_block(&self, sub_cmd: &ArgMatches) -> ProtocolResult<()> {
  function latest_block_set (line 384) | pub async fn latest_block_set(&self, height: u64) -> ProtocolResult<()> {
  function latest_block_get (line 413) | pub async fn latest_block_get(&self) -> ProtocolResult<Block> {
  function block (line 417) | pub fn block(&self, sub_cmd: &ArgMatches) -> ProtocolResult<()> {
  function block_get (line 457) | pub async fn block_get(&self, height: u64) -> ProtocolResult<Option<Bloc...
  function block_set (line 461) | pub async fn block_set(&self, block_json: &str) -> ProtocolResult<()> {
  function wal (line 480) | pub fn wal(&self, sub_cmd: &ArgMatches) -> ProtocolResult<()> {
  function wal_txs_clear (line 537) | pub fn wal_txs_clear(&self) -> ProtocolResult<()> {
  function wal_txs_list (line 543) | pub fn wal_txs_list(&self) -> ProtocolResult<Vec<u64>> {
  function wal_txs_get (line 549) | pub fn wal_txs_get(&self, height: u64) -> ProtocolResult<Vec<SignedTrans...
  function wal_consensus_clear (line 555) | pub fn wal_consensus_clear(&self) -> ProtocolResult<()> {
  function backup (line 561) | pub fn backup(&self, sub_cmd: &ArgMatches) -> ProtocolResult<()> {
  function backup_save (line 580) | pub fn backup_save<P: AsRef<Path>>(&self, to: P) -> ProtocolResult<()> {
  function backup_restore (line 598) | pub fn backup_restore<P: AsRef<Path>>(&self, from: P) -> ProtocolResult<...

FILE: core/cli/src/tests/mod.rs
  constant SAVE_DIR (line 14) | const SAVE_DIR: &str = "./free-space/save";
  constant DATA_DIR (line 15) | const DATA_DIR: &str = "./free-space/data";
  constant CONFIG_PATH (line 16) | const CONFIG_PATH: &str = "./src/tests/config.toml";
  constant GENESIS_PATH (line 17) | const GENESIS_PATH: &str = "./src/tests/genesis.toml";
  function test_lineally (line 20) | fn test_lineally() {
  function save_restore (line 45) | fn save_restore() {
  function block_get (line 85) | fn block_get() -> Block {
  function block_set (line 131) | fn block_set() {
  function latest_get (line 182) | fn latest_get(expect: u64) -> Block {
  function latest_set (line 226) | fn latest_set() {
  function prepare (line 274) | fn prepare() {
  function clean (line 371) | fn clean() {
  function run (line 378) | fn run(cmd: Vec<&str>) -> ProtocolResult<()> {

FILE: core/cli/src/tests/service_mapping.rs
  type DefaultServiceMapping (line 13) | pub struct DefaultServiceMapping;
  method get_service (line 16) | fn get_service<SDK: 'static + ServiceSDK, Factory: SDKFactory<SDK>>(
  method list_service_name (line 45) | fn list_service_name(&self) -> Vec<String> {
  type MappingError (line 57) | pub enum MappingError {
  method from (line 65) | fn from(err: MappingError) -> ProtocolError {

FILE: core/consensus/src/adapter.rs
  type OverlordConsensusAdapter (line 43) | pub struct OverlordConsensusAdapter<
  method get_txs_from_mempool (line 75) | async fn get_txs_from_mempool(
  method sync_txs (line 86) | async fn sync_txs(&self, ctx: Context, txs: Vec<Hash>) -> ProtocolResult...
  method get_full_txs (line 91) | async fn get_full_txs(
  method transmit (line 100) | async fn transmit(
  method execute (line 125) | async fn execute(
  method get_last_validators (line 160) | async fn get_last_validators(
  method get_current_height (line 175) | async fn get_current_height(&self, ctx: Context) -> ProtocolResult<u64> {
  method pull_block (line 181) | async fn pull_block(&self, ctx: Context, height: u64, end: &str) -> Prot...
  method verify_txs (line 191) | async fn verify_txs(&self, ctx: Context, height: u64, txs: &[Hash]) -> P...
  method update_status (line 217) | fn update_status(
  method sync_exec (line 249) | fn sync_exec(
  method get_block_from_remote (line 271) | async fn get_block_from_remote(&self, ctx: Context, height: u64) -> Prot...
  method get_txs_from_remote (line 305) | async fn get_txs_from_remote(
  method get_proof_from_remote (line 325) | async fn get_proof_from_remote(&self, ctx: Context, height: u64) -> Prot...
  method save_block (line 355) | async fn save_block(&self, ctx: Context, block: Block) -> ProtocolResult...
  method save_proof (line 360) | async fn save_proof(&self, ctx: Context, proof: Proof) -> ProtocolResult...
  method save_signed_txs (line 369) | async fn save_signed_txs(
  method save_receipts (line 384) | async fn save_receipts(
  method flush_mempool (line 398) | async fn flush_mempool(&self, ctx: Context, ordered_tx_hashes: &[Hash]) ...
  method get_block_by_height (line 404) | async fn get_block_by_height(&self, ctx: Context, height: u64) -> Protoc...
  method get_block_header_by_height (line 411) | async fn get_block_header_by_height(
  method get_current_height (line 424) | async fn get_current_height(&self, ctx: Context) -> ProtocolResult<u64> {
  method get_txs_from_storage (line 433) | async fn get_txs_from_storage(
  method broadcast_height (line 450) | async fn broadcast_height(&self, ctx: Context, height: u64) -> ProtocolR...
  method get_metadata (line 458) | fn get_metadata(
  method tag_consensus (line 491) | fn tag_consensus(&self, ctx: Context, pub_keys: Vec<Bytes>) -> ProtocolR...
  method report_bad (line 501) | fn report_bad(&self, ctx: Context, feedback: TrustFeedback) {
  method set_args (line 505) | fn set_args(&self, _context: Context, timeout_gap: u64, cycles_limit: u6...
  method verify_block_header (line 512) | async fn verify_block_header(&self, ctx: Context, block: &Block) -> Prot...
  method verify_proof (line 624) | async fn verify_proof(
  method verify_proof_signature (line 745) | fn verify_proof_signature(
  method verify_proof_weight (line 767) | fn verify_proof_weight(
  function new (line 823) | pub fn new(
  function take_exec_demon (line 857) | pub fn take_exec_demon(&mut self) -> ExecDemons<S, DB, EF, Mapping> {
  function set_overlord_handler (line 862) | pub fn set_overlord_handler(&self, handler: OverlordHandler<FixedPill>) {
  type ExecDemons (line 868) | pub struct ExecDemons<S, DB, EF, Mapping> {
  function new (line 885) | fn new(
  function run (line 902) | pub async fn run(mut self) {
  function process (line 914) | async fn process(&mut self) -> ProtocolResult<()> {
  function exec (line 926) | async fn exec(&self, ctx: Context, info: ExecuteInfo) -> ProtocolResult<...
  function save_receipts (line 978) | async fn save_receipts(
  function gen_executed_info (line 988) | fn gen_executed_info(

FILE: core/consensus/src/consensus.rs
  type OverlordConsensus (line 25) | pub struct OverlordConsensus<Adapter: ConsensusAdapter + 'static> {
  method set_proposal (line 37) | async fn set_proposal(&self, ctx: Context, proposal: Vec<u8>) -> Protoco...
  method set_vote (line 50) | async fn set_vote(&self, ctx: Context, vote: Vec<u8>) -> ProtocolResult<...
  method set_qc (line 76) | async fn set_qc(&self, ctx: Context, qc: Vec<u8>) -> ProtocolResult<()> {
  method set_choke (line 90) | async fn set_choke(&self, ctx: Context, choke: Vec<u8>) -> ProtocolResul...
  function new (line 105) | pub fn new(
  function get_overlord_handler (line 151) | pub fn get_overlord_handler(&self) -> OverlordHandler<FixedPill> {
  function run (line 155) | pub async fn run(
  function gen_overlord_status (line 171) | pub fn gen_overlord_status(
  type OverlordMsgExt (line 204) | trait OverlordMsgExt {
    method get_height (line 205) | fn get_height(&self) -> String;
    method get_round (line 206) | fn get_round(&self) -> String;
    method get_height (line 210) | fn get_height(&self) -> String {
    method get_round (line 221) | fn get_round(&self) -> String {
  function tracing_overlord_message (line 239) | pub fn tracing_overlord_message<T: overlord::Codec>(ctx: Context, msg: &...

FILE: core/consensus/src/engine.rs
  constant RETRY_COMMIT_INTERVAL (line 41) | const RETRY_COMMIT_INTERVAL: u64 = 1000;
  constant RETRY_CHECK_ROOT_LIMIT (line 42) | const RETRY_CHECK_ROOT_LIMIT: u8 = 15;
  constant RETRY_CHECK_ROOT_INTERVAL (line 43) | const RETRY_CHECK_ROOT_INTERVAL: u64 = 100;
  type ConsensusEngine (line 47) | pub struct ConsensusEngine<Adapter> {
  function get_block (line 68) | async fn get_block(
  function check_block (line 160) | async fn check_block(
  function commit (line 233) | async fn commit(
  function broadcast_to_other (line 370) | async fn broadcast_to_other(
  function transmit_to_relayer (line 405) | async fn transmit_to_relayer(
  function get_authority_list (line 445) | async fn get_authority_list(
  function report_error (line 478) | fn report_error(&self, ctx: Context, err: OverlordError) {
  function report_view_change (line 487) | fn report_view_change(&self, cx: Context, height: u64, round: u64, reaso...
  method save (line 508) | async fn save(&self, info: Bytes) -> Result<(), Box<dyn Error + Send>> {
  method load (line 515) | async fn load(&self) -> Result<Option<Bytes>, Box<dyn Error + Send>> {
  function new (line 522) | pub fn new(
  function exec (line 546) | pub async fn exec(
  function inner_check_block (line 574) | async fn inner_check_block(&self, ctx: Context, block: &Block) -> Protoc...
  function check_block_roots (line 654) | fn check_block_roots(&self, ctx: Context, block: &BlockHeader) -> Protoc...
  function check_order_transactions (line 711) | fn check_order_transactions(
  function update_status (line 746) | pub async fn update_status(
  function update_overlord_crypto (line 805) | fn update_overlord_crypto(&self, metadata: Metadata) -> ProtocolResult<(...
  function metric_commit (line 810) | fn metric_commit(&self, current_height: u64, txs_len: usize) {
  function get_current_status (line 823) | pub fn get_current_status(&self) -> crate::status::CurrentConsensusStatus {
  function generate_new_crypto_map (line 828) | pub fn generate_new_crypto_map(metadata: Metadata) -> ProtocolResult<Has...
  function covert_to_overlord_authority (line 842) | fn covert_to_overlord_authority(validators: &[Validator]) -> Vec<Node> {
  function sync_txs (line 855) | async fn sync_txs<CA: ConsensusAdapter>(
  function validate_timestamp (line 863) | fn validate_timestamp(
  function gauge_txs_len (line 879) | fn gauge_txs_len(pill: &Pill) {
  function test_validate_timestamp (line 890) | fn test_validate_timestamp() {

FILE: core/consensus/src/fixed_types.rs
  type ConsensusRpcRequest (line 13) | pub enum ConsensusRpcRequest {
  type ConsensusRpcResponse (line 19) | pub enum ConsensusRpcResponse {
  method encode (line 25) | fn encode(&mut self) -> ProtocolResult<Bytes> {
  method decode (line 46) | fn decode(mut bytes: Bytes) -> ProtocolResult<Self> {
  type FixedPill (line 67) | pub struct FixedPill {
    method get_ordered_hashes (line 84) | pub fn get_ordered_hashes(&self) -> Vec<Hash> {
    method get_propose_hashes (line 88) | pub fn get_propose_hashes(&self) -> Vec<Hash> {
  method encode (line 72) | fn encode(&self) -> Result<Bytes, Box<dyn Error + Send>> {
  method decode (line 77) | fn decode(data: Bytes) -> Result<Self, Box<dyn Error + Send>> {
  type FixedBlock (line 94) | pub struct FixedBlock {
    method new (line 110) | pub fn new(inner: Block) -> Self {
  method encode (line 99) | fn encode(&mut self) -> ProtocolResult<Bytes> {
  method decode (line 103) | fn decode(bytes: Bytes) -> ProtocolResult<Self> {
  type FixedProof (line 116) | pub struct FixedProof {
    method new (line 132) | pub fn new(inner: Proof) -> Self {
  method encode (line 121) | fn encode(&mut self) -> ProtocolResult<Bytes> {
  method decode (line 125) | fn decode(bytes: Bytes) -> ProtocolResult<Self> {
  type FixedHeight (line 138) | pub struct FixedHeight {
    method new (line 143) | pub fn new(inner: u64) -> Self {
  type PullTxsRequest (line 149) | pub struct PullTxsRequest {
    method new (line 156) | pub fn new(height: u64, inner: Vec<Hash>) -> Self {
  type FixedSignedTxs (line 162) | pub struct FixedSignedTxs {
    method new (line 168) | pub fn new(inner: Vec<SignedTransaction>) -> Self {
  constant PUB_KEY_STR (line 189) | const PUB_KEY_STR: &str = "02ee34d1ce8270cd236e9455d4ab9e756c4478779b1a2...
  function gen_block (line 191) | fn gen_block(height: u64, block_hash: Hash) -> Block {
  function mock_proof (line 218) | fn mock_proof(block_hash: Hash) -> Proof {
  function gen_random_bytes (line 228) | fn gen_random_bytes(len: usize) -> Vec<u8> {
  function gen_signed_tx (line 232) | fn gen_signed_tx() -> SignedTransaction {
  function test_txs_codec (line 265) | fn test_txs_codec() {
  function test_block_codec (line 279) | async fn test_block_codec() {

FILE: core/consensus/src/lib.rs
  constant DEFAULT_OVERLORD_GAP (line 36) | pub const DEFAULT_OVERLORD_GAP: usize = 5;
  constant DEFAULT_SYNC_TXS_CHUNK_SIZE (line 37) | pub const DEFAULT_SYNC_TXS_CHUNK_SIZE: usize = 5000;
  type ConsensusType (line 40) | pub enum ConsensusType {
  type ConsensusError (line 68) | pub enum ConsensusError {
  type BlockHeaderField (line 171) | pub enum BlockHeaderField {
  type BlockProofField (line 189) | pub enum BlockProofField {
  method from (line 215) | fn from(err: ConsensusError) -> ProtocolError {

FILE: core/consensus/src/message.rs
  constant END_GOSSIP_SIGNED_PROPOSAL (line 23) | pub const END_GOSSIP_SIGNED_PROPOSAL: &str = "/gossip/consensus/signed_p...
  constant END_GOSSIP_SIGNED_VOTE (line 24) | pub const END_GOSSIP_SIGNED_VOTE: &str = "/gossip/consensus/signed_vote";
  constant END_GOSSIP_AGGREGATED_VOTE (line 25) | pub const END_GOSSIP_AGGREGATED_VOTE: &str = "/gossip/consensus/qc";
  constant END_GOSSIP_SIGNED_CHOKE (line 26) | pub const END_GOSSIP_SIGNED_CHOKE: &str = "/gossip/consensus/signed_choke";
  constant RPC_SYNC_PULL_BLOCK (line 27) | pub const RPC_SYNC_PULL_BLOCK: &str = "/rpc_call/consensus/sync_pull_blo...
  constant RPC_RESP_SYNC_PULL_BLOCK (line 28) | pub const RPC_RESP_SYNC_PULL_BLOCK: &str = "/rpc_resp/consensus/sync_pul...
  constant RPC_SYNC_PULL_TXS (line 29) | pub const RPC_SYNC_PULL_TXS: &str = "/rpc_call/consensus/sync_pull_txs";
  constant RPC_RESP_SYNC_PULL_TXS (line 30) | pub const RPC_RESP_SYNC_PULL_TXS: &str = "/rpc_resp/consensus/sync_pull_...
  constant BROADCAST_HEIGHT (line 31) | pub const BROADCAST_HEIGHT: &str = "/gossip/consensus/broadcast_height";
  constant RPC_SYNC_PULL_PROOF (line 32) | pub const RPC_SYNC_PULL_PROOF: &str = "/rpc_call/consensus/sync_pull_pro...
  constant RPC_RESP_SYNC_PULL_PROOF (line 33) | pub const RPC_RESP_SYNC_PULL_PROOF: &str = "/rpc_resp/consensus/sync_pul...
  type Proposal (line 36) | pub struct Proposal(pub Vec<u8>);
    method from (line 39) | fn from(proposal: SignedProposal<C>) -> Self {
  type Vote (line 45) | pub struct Vote(pub Vec<u8>);
    method from (line 48) | fn from(vote: SignedVote) -> Self {
  type QC (line 54) | pub struct QC(pub Vec<u8>);
    method from (line 57) | fn from(aggregated_vote: AggregatedVote) -> Self {
  type RichHeight (line 63) | pub struct RichHeight(pub Vec<u8>);
    method from (line 66) | fn from(id: FixedHeight) -> Self {
  type Choke (line 72) | pub struct Choke(pub Vec<u8>);
    method from (line 75) | fn from(signed_choke: SignedChoke) -> Self {
  type ProposalMessageHandler (line 80) | pub struct ProposalMessageHandler<C> {
  function new (line 85) | pub fn new(consensus: Arc<C>) -> Self {
  type Message (line 92) | type Message = Proposal;
  method process (line 95) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type VoteMessageHandler (line 105) | pub struct VoteMessageHandler<C> {
  function new (line 110) | pub fn new(consensus: Arc<C>) -> Self {
  type Message (line 117) | type Message = Vote;
  method process (line 120) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type QCMessageHandler (line 130) | pub struct QCMessageHandler<C> {
  function new (line 135) | pub fn new(consensus: Arc<C>) -> Self {
  type Message (line 142) | type Message = QC;
  method process (line 145) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type ChokeMessageHandler (line 155) | pub struct ChokeMessageHandler<C> {
  function new (line 160) | pub fn new(consensus: Arc<C>) -> Self {
  type Message (line 167) | type Message = Choke;
  method process (line 170) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type RemoteHeightMessageHandler (line 180) | pub struct RemoteHeightMessageHandler<Sy> {
  function new (line 185) | pub fn new(synchronization: Arc<Sy>) -> Self {
  type Message (line 192) | type Message = u64;
  method process (line 195) | async fn process(&self, ctx: Context, remote_height: Self::Message) -> T...
  type PullBlockRpcHandler (line 215) | pub struct PullBlockRpcHandler<R, S> {
  function new (line 225) | pub fn new(rpc: Arc<R>, storage: Arc<S>) -> Self {
  type Message (line 232) | type Message = FixedHeight;
  method process (line 235) | async fn process(&self, ctx: Context, msg: FixedHeight) -> TrustFeedback {
  type PullProofRpcHandler (line 252) | pub struct PullProofRpcHandler<R, S> {
  function new (line 262) | pub fn new(rpc: Arc<R>, storage: Arc<S>) -> Self {
  type Message (line 269) | type Message = FixedHeight;
  method process (line 272) | async fn process(&self, ctx: Context, height: FixedHeight) -> TrustFeedb...
  type PullTxsRpcHandler (line 306) | pub struct PullTxsRpcHandler<R, S> {
  function new (line 316) | pub fn new(rpc: Arc<R>, storage: Arc<S>) -> Self {
  type Message (line 323) | type Message = PullTxsRequest;
  method process (line 326) | async fn process(&self, ctx: Context, msg: PullTxsRequest) -> TrustFeedb...

FILE: core/consensus/src/status.rs
  type StatusAgent (line 15) | pub struct StatusAgent {
    method new (line 20) | pub fn new(status: CurrentConsensusStatus) -> Self {
    method update_by_executed (line 26) | pub fn update_by_executed(&self, info: ExecutedInfo) {
    method update_by_committed (line 30) | pub fn update_by_committed(
    method replace (line 43) | pub fn replace(&self, new_status: CurrentConsensusStatus) {
    method to_inner (line 60) | pub fn to_inner(&self) -> CurrentConsensusStatus {
  type CurrentConsensusStatus (line 77) | pub struct CurrentConsensusStatus {
    method get_latest_state_root (line 100) | pub fn get_latest_state_root(&self) -> MerkleRoot {
    method update_by_executed (line 107) | pub(crate) fn update_by_executed(&mut self, info: ExecutedInfo) {
    method update_by_committed (line 125) | pub(crate) fn update_by_committed(
    method set_metadata (line 147) | pub(crate) fn set_metadata(&mut self, metadata: Metadata) {
    method split_off (line 169) | fn split_off(&mut self, block: &Block) {
  type ExecutedInfo (line 210) | pub struct ExecutedInfo {
    method new (line 220) | pub fn new(ctx: Context, height: u64, order_root: MerkleRoot, resp: Ex...

FILE: core/consensus/src/synchronization.rs
  constant POLLING_BROADCAST (line 22) | const POLLING_BROADCAST: u64 = 2000;
  constant WAIT_EXECUTION (line 23) | const WAIT_EXECUTION: u64 = 1000;
  constant ONCE_SYNC_BLOCK_LIMIT (line 24) | const ONCE_SYNC_BLOCK_LIMIT: u64 = 50;
  type RichBlock (line 27) | pub struct RichBlock {
  type OverlordSynchronization (line 32) | pub struct OverlordSynchronization<Adapter: SynchronizationAdapter> {
  method receive_remote_block (line 48) | async fn receive_remote_block(&self, ctx: Context, remote_height: u64) -...
  function new (line 108) | pub fn new(
  function polling_broadcast (line 128) | pub async fn polling_broadcast(&self) -> ProtocolResult<()> {
  function start_sync (line 144) | async fn start_sync(
  function commit_block (line 298) | async fn commit_block(
  function get_rich_block_from_remote (line 362) | async fn get_rich_block_from_remote(
  function get_block_from_remote (line 384) | async fn get_block_from_remote(&self, ctx: Context, height: u64) -> Prot...
  function save_chain_data (line 391) | async fn save_chain_data(
  function exec_block (line 412) | pub async fn exec_block(
  function init_status_agent (line 442) | async fn init_status_agent(&self) -> ProtocolResult<StatusAgent> {
  function need_sync (line 460) | async fn need_sync(&self, ctx: Context, remote_height: u64) -> ProtocolR...
  function update_status (line 497) | fn update_status(&self, ctx: Context, sync_status_agent: StatusAgent) ->...

FILE: core/consensus/src/tests/engine.rs
  function test_repetitive_commit (line 34) | async fn test_repetitive_commit() {
  function mock_commit (line 55) | fn mock_commit(block: Block) -> Commit<FixedPill> {
  function init_engine (line 75) | fn init_engine(init_status: CurrentConsensusStatus) -> ConsensusEngine<M...
  function init_crypto (line 87) | fn init_crypto() -> OverlordCrypto {
  function mock_node_info (line 103) | fn mock_node_info() -> NodeInfo {
  function mock_metadata (line 111) | fn mock_metadata() -> Metadata {
  type MockConsensusAdapter (line 130) | pub struct MockConsensusAdapter;
  method save_block (line 134) | async fn save_block(&self, _ctx: Context, _block: Block) -> ProtocolResu...
  method save_proof (line 138) | async fn save_proof(&self, _ctx: Context, _proof: Proof) -> ProtocolResu...
  method save_signed_txs (line 142) | async fn save_signed_txs(
  method save_receipts (line 151) | async fn save_receipts(
  method flush_mempool (line 160) | async fn flush_mempool(
  method get_block_by_height (line 168) | async fn get_block_by_height(&self, _ctx: Context, _height: u64) -> Prot...
  method get_block_header_by_height (line 172) | async fn get_block_header_by_height(
  method get_current_height (line 180) | async fn get_current_height(&self, _ctx: Context) -> ProtocolResult<u64> {
  method get_txs_from_storage (line 184) | async fn get_txs_from_storage(
  method verify_block_header (line 192) | async fn verify_block_header(&self, _ctx: Context, _block: &Block) -> Pr...
  method verify_proof (line 196) | async fn verify_proof(
  method broadcast_height (line 205) | async fn broadcast_height(&self, _ctx: Context, _height: u64) -> Protoco...
  method get_metadata (line 209) | fn get_metadata(
  method report_bad (line 220) | fn report_bad(&self, _ctx: Context, _feedback: TrustFeedback) {}
  method set_args (line 222) | fn set_args(
  method tag_consensus (line 231) | fn tag_consensus(&self, _ctx: Context, _peer_ids: Vec<Bytes>) -> Protoco...
  method verify_proof_signature (line 235) | fn verify_proof_signature(
  method verify_proof_weight (line 246) | fn verify_proof_weight(
  method get_txs_from_mempool (line 259) | async fn get_txs_from_mempool(
  method sync_txs (line 269) | async fn sync_txs(&self, _ctx: Context, _txs: Vec<Hash>) -> ProtocolResu...
  method get_full_txs (line 273) | async fn get_full_txs(
  method transmit (line 281) | async fn transmit(
  method execute (line 291) | async fn execute(
  method get_last_validators (line 307) | async fn get_last_validators(
  method pull_block (line 315) | async fn pull_block(&self, _ctx: Context, _height: u64, _end: &str) -> P...
  method get_current_height (line 319) | async fn get_current_height(&self, _ctx: Context) -> ProtocolResult<u64> {
  method verify_txs (line 323) | async fn verify_txs(&self, _ctx: Context, _height: u64, _txs: &[Hash]) -...

FILE: core/consensus/src/tests/mod.rs
  constant HEIGHT_TEN (line 12) | const HEIGHT_TEN: u64 = 10;
  function mock_block_from_status (line 14) | fn mock_block_from_status(status: &CurrentConsensusStatus) -> Block {
  function mock_current_status (line 39) | fn mock_current_status(exec_lag: u64) -> CurrentConsensusStatus {
  function mock_proof (line 65) | fn mock_proof(proof_height: u64) -> Proof {
  function mock_roots (line 75) | fn mock_roots(len: u64) -> Vec<MerkleRoot> {
  function mock_hash (line 79) | fn mock_hash() -> Hash {
  function mock_address (line 83) | fn mock_address() -> Address {
  function get_random_bytes (line 88) | fn get_random_bytes(len: usize) -> Bytes {
  function mock_pub_key (line 93) | fn mock_pub_key() -> Hex {
  function mock_validators (line 100) | fn mock_validators(len: usize) -> Vec<Validator> {
  function mock_validator (line 104) | fn mock_validator() -> Validator {

FILE: core/consensus/src/tests/status.rs
  function test_update_by_executed (line 13) | fn test_update_by_executed() {
  function test_update_by_committed (line 38) | fn test_update_by_committed() {
  function check_metadata (line 68) | fn check_metadata(status: &CurrentConsensusStatus, metadata: &Metadata) {
  function check_vec (line 78) | fn check_vec(status_before: &CurrentConsensusStatus, status_after: &Curr...
  function mock_metadata (line 98) | fn mock_metadata() -> Metadata {
  function mock_validators_extend (line 120) | fn mock_validators_extend(len: usize) -> Vec<ValidatorExtend> {
  function mock_executed_info (line 135) | fn mock_executed_info(height: u64) -> ExecutedInfo {

FILE: core/consensus/src/tests/synchronization.rs
  constant PUB_KEY_STR (line 36) | const PUB_KEY_STR: &str = "02ef0cb0d7bc6c18b4bea1f5908d9106522b35ab3c399...
  function sync_gap_test (line 40) | fn sync_gap_test() {
  type SafeHashMap (line 124) | pub type SafeHashMap<K, V> = Arc<RwLock<HashMap<K, V>>>;
  type MockCommonConsensusAdapter (line 126) | pub struct MockCommonConsensusAdapter {
    method new (line 137) | pub fn new(
  method update_status (line 160) | fn update_status(
  method sync_exec (line 174) | fn sync_exec(
  method get_block_from_remote (line 184) | async fn get_block_from_remote(&self, _: Context, height: u64) -> Protoc...
  method get_txs_from_remote (line 190) | async fn get_txs_from_remote(
  method get_proof_from_remote (line 207) | async fn get_proof_from_remote(&self, _: Context, height: u64) -> Protoc...
  method save_block (line 215) | async fn save_block(&self, _: Context, block: Block) -> ProtocolResult<(...
  method save_proof (line 222) | async fn save_proof(&self, _: Context, _: Proof) -> ProtocolResult<()> {
  method save_signed_txs (line 227) | async fn save_signed_txs(
  method save_receipts (line 240) | async fn save_receipts(&self, _: Context, _: u64, _: Vec<Receipt>) -> Pr...
  method flush_mempool (line 245) | async fn flush_mempool(&self, _: Context, _: &[Hash]) -> ProtocolResult<...
  method get_block_by_height (line 250) | async fn get_block_by_height(&self, _: Context, height: u64) -> Protocol...
  method get_block_header_by_height (line 254) | async fn get_block_header_by_height(
  method get_current_height (line 269) | async fn get_current_height(&self, _: Context) -> ProtocolResult<u64> {
  method get_txs_from_storage (line 273) | async fn get_txs_from_storage(
  method broadcast_height (line 289) | async fn broadcast_height(&self, _: Context, _: u64) -> ProtocolResult<(...
  method get_metadata (line 293) | fn get_metadata(
  method tag_consensus (line 319) | fn tag_consensus(&self, _: Context, _: Vec<Bytes>) -> ProtocolResult<()> {
  method report_bad (line 323) | fn report_bad(&self, _ctx: Context, _feedback: TrustFeedback) {}
  method set_args (line 325) | fn set_args(
  method verify_block_header (line 335) | async fn verify_block_header(&self, ctx: Context, block: &Block) -> Prot...
  method verify_proof (line 438) | async fn verify_proof(
  method verify_proof_signature (line 548) | fn verify_proof_signature(
  method verify_proof_weight (line 569) | fn verify_proof_weight(
  function mock_crypto (line 614) | fn mock_crypto() -> OverlordCrypto {
  function gen_remote_tx_hashmap (line 619) | fn gen_remote_tx_hashmap(list: Vec<RichBlock>) -> SafeHashMap<Hash, Sign...
  function gen_remote_block_hashmap (line 631) | fn gen_remote_block_hashmap(list: Vec<RichBlock>) -> SafeHashMap<u64, Bl...
  function gen_remote_proof_hashmap (line 640) | fn gen_remote_proof_hashmap(list: Vec<Proof>) -> SafeHashMap<u64, Proof> {
  function mock_chained_rich_block (line 649) | fn mock_chained_rich_block(len: u64, gap: u64, key_tool: &KeyTool) -> (V...
  function mock_genesis_rich_block (line 760) | fn mock_genesis_rich_block() -> RichBlock {
  function get_receipt (line 805) | fn get_receipt(tx: &SignedTransaction, height: u64) -> Receipt {
  function mock_tx_list (line 825) | fn mock_tx_list(num: usize, height: u64) -> Vec<SignedTransaction> {
  function mock_proof (line 877) | fn mock_proof(block_hash: Hash, height: u64, round: u64, key_tool: &KeyT...
  function exec_txs (line 946) | fn exec_txs(height: u64, txs: &[SignedTransaction]) -> (ExecutorResp, Me...
  type SignerNode (line 975) | struct SignerNode {
    method new (line 981) | pub fn new(secp_private_key: Secp256k1PrivateKey, secp_public_key: Sec...
  type KeyTool (line 989) | struct KeyTool {
    method new (line 996) | pub fn new(
  function get_mock_key_tool (line 1009) | fn get_mock_key_tool() -> KeyTool {
  function get_mock_public_keys_and_common_ref (line 1031) | fn get_mock_public_keys_and_common_ref() -> (HashMap<Bytes, BlsPublicKey...
  function mock_verifier_list (line 1080) | fn mock_verifier_list() -> Vec<ValidatorExtend> {
  function assert_sync (line 1145) | fn assert_sync(status: CurrentConsensusStatus, latest_block: Block) {

FILE: core/consensus/src/util.rs
  function time_now (line 21) | pub fn time_now() -> u64 {
  type OverlordCrypto (line 28) | pub struct OverlordCrypto {
    method new (line 123) | pub fn new(
    method update (line 135) | pub fn update(&self, new_addr_pubkey: HashMap<Bytes, BlsPublicKey>) {
    method inner_verify_aggregated_signature (line 141) | pub fn inner_verify_aggregated_signature(
  method hash (line 35) | fn hash(&self, msg: Bytes) -> Bytes {
  method sign (line 39) | fn sign(&self, hash: Bytes) -> Result<Bytes, Box<dyn Error + Send>> {
  method verify_signature (line 49) | fn verify_signature(
  method aggregate_signatures (line 73) | fn aggregate_signatures(
  method verify_aggregated_signature (line 102) | fn verify_aggregated_signature(
  type ExecuteInfo (line 164) | pub struct ExecuteInfo {
  function check_list_roots (line 177) | pub fn check_list_roots<T: Eq>(cache_roots: &[T], block_roots: &[T]) -> ...
  function digest_signed_transactions (line 185) | pub fn digest_signed_transactions(signed_txs: &[SignedTransaction]) -> P...
  function convert_hex_to_bls_pubkeys (line 200) | pub fn convert_hex_to_bls_pubkeys(hex: Hex) -> ProtocolResult<BlsPublicK...
  function test_bls_amcl (line 213) | fn test_bls_amcl() {
  function test_aggregate_pubkeys_order (line 253) | fn test_aggregate_pubkeys_order() {
  function test_zip_roots (line 271) | fn test_zip_roots() {
  function test_convert_from_hex (line 285) | fn test_convert_from_hex() {

FILE: core/consensus/src/wal.rs
  type SignedTxsWAL (line 18) | pub struct SignedTxsWAL {
    method new (line 23) | pub fn new<P: AsRef<Path>>(path: P) -> Self {
    method save (line 33) | pub fn save(
    method available_height (line 71) | pub fn available_height(&self) -> ProtocolResult<Vec<u64>> {
    method remove_all (line 84) | pub fn remove_all(&self) -> ProtocolResult<()> {
    method load (line 91) | pub fn load(
    method load_by_height (line 104) | pub fn load_by_height(&self, height: u64) -> Vec<SignedTransaction> {
    method remove (line 124) | pub fn remove(&self, committed_height: u64) -> ProtocolResult<()> {
    method recover_stxs (line 146) | fn recover_stxs(&self, file_path: PathBuf) -> ProtocolResult<Vec<Signe...
  type ConsensusWal (line 158) | pub struct ConsensusWal {
    method new (line 163) | pub fn new<P: AsRef<Path>>(path: P) -> Self {
    method update_overlord_wal (line 174) | pub fn update_overlord_wal(&self, ctx: Context, info: Bytes) -> Protoc...
    method load_overlord_wal (line 248) | pub fn load_overlord_wal(&self, ctx: Context) -> ProtocolResult<Bytes> {
    method clear (line 309) | pub fn clear(&self) -> ProtocolResult<()> {
  function mock_hash (line 351) | fn mock_hash() -> Hash {
  function mock_address (line 355) | fn mock_address() -> Address {
  function mock_raw_tx (line 360) | fn mock_raw_tx() -> RawTransaction {
  function mock_transaction_request (line 372) | pub fn mock_transaction_request() -> TransactionRequest {
  function mock_sign_tx (line 380) | pub fn mock_sign_tx() -> SignedTransaction {
  function mock_wal_txs (line 389) | pub fn mock_wal_txs(size: usize) -> Vec<SignedTransaction> {
  function get_random_bytes (line 393) | pub fn get_random_bytes(len: usize) -> Bytes {
  function test_txs_wal (line 399) | fn test_txs_wal() {
  function test_consensus_wal (line 433) | fn test_consensus_wal() {
  function test_wal_txs_codec (line 493) | fn test_wal_txs_codec() {
  function bench_txs_rlp_encode (line 504) | fn bench_txs_rlp_encode(b: &mut Bencher) {
  function bench_txs_prost_encode (line 513) | fn bench_txs_prost_encode(b: &mut Bencher) {
  function bench_save_wal_1000_txs (line 522) | fn bench_save_wal_1000_txs(b: &mut Bencher) {
  function bench_save_wal_2000_txs (line 533) | fn bench_save_wal_2000_txs(b: &mut Bencher) {
  function bench_save_wal_4000_txs (line 544) | fn bench_save_wal_4000_txs(b: &mut Bencher) {
  function bench_save_wal_8000_txs (line 555) | fn bench_save_wal_8000_txs(b: &mut Bencher) {
  function bench_save_wal_16000_txs (line 566) | fn bench_save_wal_16000_txs(b: &mut Bencher) {

FILE: core/consensus/src/wal_proto.rs
  type FixedSignedTxs (line 12) | pub struct FixedSignedTxs {
    method from (line 18) | fn from(txs: fixed_types::FixedSignedTxs) -> FixedSignedTxs {
  type Error (line 29) | type Error = ProtocolError;
  function try_from (line 31) | fn try_from(txs: FixedSignedTxs) -> Result<fixed_types::FixedSignedTxs, ...
  method encode_sync (line 43) | fn encode_sync(&self) -> ProtocolResult<Bytes> {
  method decode_sync (line 53) | fn decode_sync(data: Bytes) -> ProtocolResult<Self> {

FILE: core/mempool/src/adapter/message.rs
  constant END_GOSSIP_NEW_TXS (line 14) | pub const END_GOSSIP_NEW_TXS: &str = "/gossip/mempool/new_txs";
  constant RPC_PULL_TXS (line 15) | pub const RPC_PULL_TXS: &str = "/rpc_call/mempool/pull_txs";
  constant RPC_RESP_PULL_TXS (line 16) | pub const RPC_RESP_PULL_TXS: &str = "/rpc_resp/mempool/pull_txs";
  constant RPC_RESP_PULL_TXS_SYNC (line 17) | pub const RPC_RESP_PULL_TXS_SYNC: &str = "/rpc_resp/mempool/pull_txs_sync";
  type MsgNewTxs (line 20) | pub struct MsgNewTxs {
  type NewTxsHandler (line 25) | pub struct NewTxsHandler<M> {
  function new (line 33) | pub fn new(mem_pool: Arc<M>) -> Self {
  type Message (line 43) | type Message = MsgNewTxs;
  method process (line 45) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type MsgPullTxs (line 92) | pub struct MsgPullTxs {
  type MsgPushTxs (line 99) | pub struct MsgPushTxs {
  type PullTxsHandler (line 104) | pub struct PullTxsHandler<N, M> {
  function new (line 114) | pub fn new(network: Arc<N>, mem_pool: Arc<M>) -> Self {
  type Message (line 125) | type Message = MsgPullTxs;
  method process (line 127) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...

FILE: core/mempool/src/adapter/mod.rs
  constant DEFAULT_BROADCAST_TXS_SIZE (line 42) | pub const DEFAULT_BROADCAST_TXS_SIZE: usize = 200;
  constant DEFAULT_BROADCAST_TXS_INTERVAL (line 43) | pub const DEFAULT_BROADCAST_TXS_INTERVAL: u64 = 200;
  type IntervalTxsBroadcaster (line 45) | struct IntervalTxsBroadcaster;
    method broadcast (line 48) | pub async fn broadcast<G>(
    method timer (line 85) | pub async fn timer(mut signal_tx: Sender<()>, interval: u64) {
    method do_broadcast (line 105) | async fn do_broadcast<G>(
  type DefaultMemPoolAdapter (line 138) | pub struct DefaultMemPoolAdapter<EF, C, N, S, DB, Mapping> {
  function new (line 164) | pub fn new(
  method pull_txs (line 222) | async fn pull_txs(
  method broadcast_tx (line 241) | async fn broadcast_tx(&self, _ctx: Context, stx: SignedTransaction) -> P...
  method check_authorization (line 257) | async fn check_authorization(
  method check_transaction (line 343) | async fn check_transaction(&self, ctx: Context, stx: &SignedTransaction)...
  method check_storage_exist (line 429) | async fn check_storage_exist(&self, ctx: Context, tx_hash: &Hash) -> Pro...
  method get_latest_height (line 440) | async fn get_latest_height(&self, ctx: Context) -> ProtocolResult<u64> {
  method get_transactions_from_storage (line 445) | async fn get_transactions_from_storage(
  method report_good (line 462) | fn report_good(&self, ctx: Context) {
  method set_args (line 468) | fn set_args(&self, timeout_gap: u64, cycles_limit: u64, max_tx_size: u64) {
  type AdapterError (line 476) | pub enum AdapterError {
    method from (line 487) | fn from(_error: TrySendError<T>) -> AdapterError {
  method from (line 493) | fn from(error: AdapterError) -> ProtocolError {
  type MockGossip (line 523) | struct MockGossip {
    method new (line 529) | pub fn new(signal_tx: UnboundedSender<()>) -> Self {
  method broadcast (line 539) | async fn broadcast<M>(
  method multicast (line 559) | async fn multicast<'a, M, P>(
  function test_interval_timer (line 583) | async fn test_interval_timer() {
  function test_interval_broadcast_reach_cache_size (line 595) | async fn test_interval_broadcast_reach_cache_size() {
  function test_interval_broadcast_reach_interval (line 624) | async fn test_interval_broadcast_reach_interval() {
  function test_interval_broadcast (line 654) | async fn test_interval_broadcast() {

FILE: core/mempool/src/context.rs
  constant TXS_ORIGINAL_KEY (line 3) | const TXS_ORIGINAL_KEY: &str = "txs_original";
  constant NETWORK_TXS (line 4) | const NETWORK_TXS: usize = 1;
  type TxContext (line 6) | pub(crate) trait TxContext {
    method mark_network_origin_new_txs (line 7) | fn mark_network_origin_new_txs(&self) -> Self;
    method is_network_origin_txs (line 9) | fn is_network_origin_txs(&self) -> bool;
    method mark_network_origin_new_txs (line 13) | fn mark_network_origin_new_txs(&self) -> Self {
    method is_network_origin_txs (line 17) | fn is_network_origin_txs(&self) -> bool {

FILE: core/mempool/src/lib.rs
  type HashMemPool (line 38) | pub struct HashMemPool<Adapter: MemPoolAdapter> {
  function new (line 58) | pub async fn new(
  function get_tx_cache (line 81) | pub fn get_tx_cache(&self) -> &TxCache {
  function get_callback_cache (line 85) | pub fn get_callback_cache(&self) -> &Map<SignedTransaction> {
  function get_adapter (line 89) | pub fn get_adapter(&self) -> &Adapter {
  function show_unknown_txs (line 93) | async fn show_unknown_txs(&self, tx_hashes: &[Hash]) -> Vec<Hash> {
  function initial_insert (line 106) | async fn initial_insert(&self, ctx: Context, tx: SignedTransaction) -> P...
  function insert_tx (line 116) | async fn insert_tx(
  function verify_tx_in_parallel (line 150) | async fn verify_tx_in_parallel(&self, ctx: Context, tx_ptrs: Vec<usize>)...
  method insert (line 192) | async fn insert(&self, ctx: Context, tx: SignedTransaction) -> ProtocolR...
  method package (line 196) | async fn package(
  method flush (line 238) | async fn flush(&self, ctx: Context, tx_hashes: &[Hash]) -> ProtocolResul...
  method get_full_txs (line 258) | async fn get_full_txs(
  method ensure_order_txs (line 304) | async fn ensure_order_txs(
  method sync_propose_txs (line 351) | async fn sync_propose_txs(
  method set_args (line 372) | fn set_args(&self, timeout_gap: u64, cycles_limit: u64, max_tx_size: u64) {
  function check_dup_order_hashes (line 379) | fn check_dup_order_hashes(order_tx_hashes: &[Hash]) -> ProtocolResult<()> {
  type TxType (line 393) | pub enum TxType {
  type MemPoolError (line 399) | pub enum MemPoolError {
  method from (line 476) | fn from(error: MemPoolError) -> ProtocolError {

FILE: core/mempool/src/map.rs
  type Map (line 13) | pub struct Map<V> {
  function new (line 21) | pub fn new(cache_size: usize) -> Self {
  function insert (line 32) | pub async fn insert(&self, hash: Hash, value: V) -> Option<V> {
  function contains_key (line 37) | pub async fn contains_key(&self, hash: &Hash) -> bool {
  function get (line 42) | pub async fn get(&self, hash: &Hash) -> Option<V> {
  function remove (line 47) | pub async fn remove(&self, hash: &Hash) {
  function remove_batch (line 52) | pub async fn remove_batch(&self, hashes: &[Hash]) {
  function len (line 72) | pub async fn len(&self) -> usize {
  function clear (line 80) | pub async fn clear(&self) {
  function get_bucket (line 95) | fn get_bucket(&self, hash: &Hash) -> &Bucket<V> {
  function get_index (line 100) | fn get_index(hash: &Hash) -> usize {
  type Bucket (line 104) | struct Bucket<V> {
  function insert (line 115) | async fn insert(&self, hash: Hash, value: V) -> Option<V> {
  function contains_key (line 124) | async fn contains_key(&self, hash: &Hash) -> bool {
  function get (line 128) | async fn get(&self, hash: &Hash) -> Option<V> {
  function remove (line 132) | async fn remove(&self, hash: &Hash) {
  function remove_batch (line 137) | async fn remove_batch(&self, hashes: Vec<Hash>) {
  function len (line 144) | async fn len(&self) -> usize {
  function clear (line 148) | async fn clear(&self) {
  constant GEN_TX_SIZE (line 168) | const GEN_TX_SIZE: usize = 1000;
  function bench_map_insert (line 171) | fn bench_map_insert(b: &mut Bencher) {
  function bench_std_map_insert (line 185) | fn bench_std_map_insert(b: &mut Bencher) {
  function bench_chashmap_insert (line 197) | fn bench_chashmap_insert(b: &mut Bencher) {
  function mock_txs (line 208) | fn mock_txs(size: usize) -> Vec<(Hash, Hash)> {

FILE: core/mempool/src/tests/mempool.rs
  function test_dup_order_hashes (line 31) | fn test_dup_order_hashes() {
  function test_insert (line 51) | async fn test_insert() {
  function test_package (line 85) | async fn test_package() {
  function test_package_order_consistent_with_insert_order (line 111) | async fn test_package_order_consistent_with_insert_order() {
  function test_flush (line 130) | async fn test_flush() {
  function test_ensure_order_txs (line 182) | async fn test_ensure_order_txs() {
  function test_sync_propose_txs (line 192) | async fn test_sync_propose_txs() {
  function bench_insert (line 233) | fn bench_insert(b: &mut Bencher) {
  function bench_insert_serial_1 (line 244) | fn bench_insert_serial_1(b: &mut Bencher) {
  function bench_insert_serial_10 (line 258) | fn bench_insert_serial_10(b: &mut Bencher) {
  function bench_insert_serial_100 (line 272) | fn bench_insert_serial_100(b: &mut Bencher) {
  function bench_insert_serial_1000 (line 286) | fn bench_insert_serial_1000(b: &mut Bencher) {
  function bench_package (line 300) | fn bench_package(b: &mut Bencher) {
  function bench_get_10000_full_txs (line 316) | fn bench_get_10000_full_txs(b: &mut Bencher) {
  function bench_get_20000_full_txs (line 329) | fn bench_get_20000_full_txs(b: &mut Bencher) {
  function bench_get_40000_full_txs (line 342) | fn bench_get_40000_full_txs(b: &mut Bencher) {
  function bench_get_80000_full_txs (line 355) | fn bench_get_80000_full_txs(b: &mut Bencher) {
  function bench_flush (line 368) | fn bench_flush(b: &mut Bencher) {
  function bench_sign_with_spawn_list (line 382) | async fn bench_sign_with_spawn_list() {
  function bench_sign (line 410) | async fn bench_sign() {
  function bench_mock_txs (line 429) | fn bench_mock_txs(b: &mut Bencher) {
  function bench_check_sig (line 436) | fn bench_check_sig(b: &mut Bencher) {
  function bench_check_sig_serial_1 (line 447) | fn bench_check_sig_serial_1(b: &mut Bencher) {
  function bench_check_sig_serial_10 (line 458) | fn bench_check_sig_serial_10(b: &mut Bencher) {
  function bench_check_sig_serial_100 (line 469) | fn bench_check_sig_serial_100(b: &mut Bencher) {
  function bench_check_sig_serial_1000 (line 480) | fn bench_check_sig_serial_1000(b: &mut Bencher) {

FILE: core/mempool/src/tests/mod.rs
  constant CYCLE_LIMIT (line 25) | const CYCLE_LIMIT: u64 = 1_000_000;
  constant TX_NUM_LIMIT (line 26) | const TX_NUM_LIMIT: u64 = 10_000;
  constant CURRENT_HEIGHT (line 27) | const CURRENT_HEIGHT: u64 = 999;
  constant POOL_SIZE (line 28) | const POOL_SIZE: usize = 100_000;
  constant MAX_TX_SIZE (line 29) | const MAX_TX_SIZE: u64 = 1024;
  constant TIMEOUT (line 30) | const TIMEOUT: u64 = 1000;
  constant TIMEOUT_GAP (line 31) | const TIMEOUT_GAP: u64 = 100;
  constant TX_CYCLE (line 32) | const TX_CYCLE: u64 = 1;
  type HashMemPoolAdapter (line 34) | pub struct HashMemPoolAdapter {
    method new (line 39) | fn new() -> HashMemPoolAdapter {
  method pull_txs (line 48) | async fn pull_txs(
  method broadcast_tx (line 63) | async fn broadcast_tx(&self, _ctx: Context, tx: SignedTransaction) -> Pr...
  method check_authorization (line 68) | async fn check_authorization(
  method check_transaction (line 77) | async fn check_transaction(
  method check_storage_exist (line 85) | async fn check_storage_exist(&self, _ctx: Context, _tx_hash: &Hash) -> P...
  method get_latest_height (line 89) | async fn get_latest_height(&self, _ctx: Context) -> ProtocolResult<u64> {
  method get_transactions_from_storage (line 93) | async fn get_transactions_from_storage(
  method report_good (line 102) | fn report_good(&self, _ctx: Context) {}
  method set_args (line 104) | fn set_args(&self, _timeout_gap: u64, _cycles_limit: u64, _max_tx_size: ...
  function default_mock_txs (line 107) | pub fn default_mock_txs(size: usize) -> Vec<SignedTransaction> {
  function mock_txs (line 111) | fn mock_txs(valid_size: usize, invalid_size: usize, timeout: u64) -> Vec...
  function default_mempool_sync (line 121) | fn default_mempool_sync() -> HashMemPool<HashMemPoolAdapter> {
  function default_mempool (line 126) | async fn default_mempool() -> HashMemPool<HashMemPoolAdapter> {
  function new_mempool (line 130) | async fn new_mempool(
  function check_hash (line 142) | async fn check_hash(tx: &SignedTransaction) -> ProtocolResult<()> {
  function check_sig (line 156) | fn check_sig(tx: &SignedTransaction) -> ProtocolResult<()> {
  function concurrent_check_sig (line 167) | async fn concurrent_check_sig(txs: Vec<SignedTransaction>) {
  function concurrent_insert (line 176) | async fn concurrent_insert(
  function concurrent_broadcast (line 191) | async fn concurrent_broadcast(
  function exec_insert (line 212) | async fn exec_insert(signed_tx: SignedTransaction, mempool: Arc<HashMemP...
  function exec_flush (line 216) | async fn exec_flush(remove_hashes: Vec<Hash>, mempool: Arc<HashMemPool<H...
  function exec_package (line 220) | async fn exec_package(
  function exec_ensure_order_txs (line 231) | async fn exec_ensure_order_txs(
  function exec_sync_propose_txs (line 241) | async fn exec_sync_propose_txs(
  function exec_get_full_txs (line 251) | async fn exec_get_full_txs(
  function mock_signed_tx (line 261) | fn mock_signed_tx(
  function get_random_bytes (line 301) | fn get_random_bytes(len: usize) -> Vec<u8> {
  function check_order_consistant (line 305) | fn check_order_consistant(mixed_tx_hashes: &MixedTxHashes, txs: &[Signed...

FILE: core/mempool/src/tx_cache.rs
  type TxWrapper (line 21) | pub struct TxWrapper {
    method new (line 37) | pub(crate) fn new(tx: SignedTransaction) -> Self {
    method propose (line 45) | pub(crate) fn propose(tx: SignedTransaction) -> Self {
    method set_removed (line 53) | pub(crate) fn set_removed(&self) {
    method is_removed (line 58) | pub(crate) fn is_removed(&self) -> bool {
    method is_proposed (line 63) | fn is_proposed(&self) -> bool {
    method is_timeout (line 68) | fn is_timeout(&self, current_height: u64, timeout: u64) -> bool {
  type SharedTx (line 75) | pub type SharedTx = Arc<TxWrapper>;
  type Stage (line 79) | enum Stage {
    method next (line 89) | fn next(&self) -> Self {
  type QueueRole (line 99) | struct QueueRole {
  type TxCache (line 115) | pub struct TxCache {
    method new (line 133) | pub fn new(pool_size: usize) -> Self {
    method len (line 143) | pub async fn len(&self) -> usize {
    method insert_new_tx (line 147) | pub async fn insert_new_tx(&self, signed_tx: SignedTransaction) -> Pro...
    method insert_propose_tx (line 154) | pub async fn insert_propose_tx(&self, signed_tx: SignedTransaction) ->...
    method show_unknown (line 161) | pub async fn show_unknown(&self, tx_hashes: &[Hash]) -> Vec<Hash> {
    method flush (line 173) | pub async fn flush(&self, tx_hashes: &[Hash], current_height: u64, tim...
    method package (line 185) | pub async fn package(
    method check_exist (line 258) | pub async fn check_exist(&self, tx_hash: &Hash) -> ProtocolResult<()> {
    method check_reach_limit (line 268) | pub async fn check_reach_limit(&self, pool_size: usize) -> ProtocolRes...
    method contain (line 275) | pub async fn contain(&self, tx_hash: &Hash) -> bool {
    method get (line 279) | pub async fn get(&self, tx_hash: &Hash) -> Option<SignedTransaction> {
    method queue_len (line 286) | pub fn queue_len(&self) -> usize {
    method insert (line 294) | async fn insert(&self, tx_hash: Hash, shared_tx: SharedTx) -> Protocol...
    method process_omission_txs (line 324) | async fn process_omission_txs(&self, queue_role: QueueRole) {
    method flush_incumbent_queue (line 347) | async fn flush_incumbent_queue(&self, current_height: u64, timeout: u6...
    method switch_queue_role (line 386) | fn switch_queue_role(&self) -> QueueRole {
    method get_queue_role (line 391) | fn get_queue_role(&self) -> QueueRole {
  constant POOL_SIZE (line 420) | const POOL_SIZE: usize = 1000;
  constant BYTES_LEN (line 421) | const BYTES_LEN: usize = 10;
  constant TX_NUM (line 422) | const TX_NUM: usize = 1000;
  constant TX_CYCLE (line 423) | const TX_CYCLE: u64 = 1;
  constant TX_NUM_LIMIT (line 424) | const TX_NUM_LIMIT: u64 = 20000;
  constant CYCLE_LIMIT (line 425) | const CYCLE_LIMIT: u64 = 500;
  constant CURRENT_H (line 426) | const CURRENT_H: u64 = 100;
  constant TIMEOUT (line 427) | const TIMEOUT: u64 = 150;
  function gen_bytes (line 429) | fn gen_bytes() -> Vec<u8> {
  function gen_signed_txs (line 433) | fn gen_signed_txs(n: usize) -> Vec<SignedTransaction> {
  function mock_signed_tx (line 441) | fn mock_signed_tx(bytes: Vec<u8>) -> SignedTransaction {
  function concurrent_insert (line 475) | async fn concurrent_insert(txs: Vec<SignedTransaction>, tx_cache: Arc<Tx...
  function concurrent_flush (line 487) | async fn concurrent_flush(tx_cache: Arc<TxCache>, tx_hashes: Vec<Hash>, ...
  function concurrent_package (line 495) | async fn concurrent_package(tx_cache: Arc<TxCache>) {
  function test_concurrent_insert (line 507) | async fn test_concurrent_insert() {
  function test_insert_overlap (line 523) | async fn test_insert_overlap() {
  function bench_gen_txs (line 541) | fn bench_gen_txs(b: &mut Bencher) {
  function bench_insert (line 548) | fn bench_insert(b: &mut Bencher) {
  function bench_flush (line 561) | fn bench_flush(b: &mut Bencher) {
  function bench_flush_insert (line 581) | fn bench_flush_insert(b: &mut Bencher) {
  function bench_package (line 605) | fn bench_package(b: &mut Bencher) {
  function bench_package_insert (line 623) | fn bench_package_insert(b: &mut Bencher) {

FILE: core/network/examples/buycopy.rs
  constant IP_ADDR (line 20) | const IP_ADDR: IpAddr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
  constant RELEASE_CHANNEL (line 22) | const RELEASE_CHANNEL: &str = "/gossip/cprd/cyperpunk7702_released";
  constant SHOP_CASH_CHANNEL (line 23) | const SHOP_CASH_CHANNEL: &str = "/rpc_call/v3/steam";
  constant SHOP_CHANNEL (line 24) | const SHOP_CHANNEL: &str = "/rpc_resp/v3/steam";
  type Cyber7702Released (line 28) | struct Cyber7702Released {
  type TakeMyMoney (line 35) | struct TakeMyMoney<N: Rpc> {
  type Message (line 41) | type Message = Cyber7702Released;
  method process (line 43) | async fn process(&self, ctx: Context, msg: Self::Message) -> TrustFeedba...
  type BuyACopy (line 68) | struct BuyACopy;
  type ACopy (line 71) | struct ACopy {
  type Checkout (line 80) | struct Checkout<N: Rpc> {
  type Message (line 86) | type Message = BuyACopy;
  method process (line 88) | async fn process(&self, ctx: Context, _msg: Self::Message) -> TrustFeedb...
  function main (line 110) | pub async fn main() {

FILE: core/network/src/common.rs
  function socket_to_multi_addr (line 47) | pub fn socket_to_multi_addr(socket_addr: SocketAddr) -> Multiaddr {
  function multiaddr_to_socket (line 54) | pub fn multiaddr_to_socket(multiaddr: &Multiaddr) -> Option<SocketAddr> {
  function resolve_if_unspecified (line 74) | pub fn resolve_if_unspecified(multiaddr: &Multiaddr) -> Result<Multiaddr...
  method id_bytes (line 112) | fn id_bytes(&self) -> Option<Cow<'_, [u8]>> {
  method has_id (line 122) | fn has_id(&self) -> bool {
  method push_id (line 126) | fn push_id(&mut self, peer_id: PeerId) {
  type HeartBeat (line 131) | pub struct HeartBeat {
    method new (line 138) | pub fn new(waker: Arc<AtomicWaker>, interval: Duration) -> Self {
  type Output (line 153) | type Output = <Delay as Future>::Output;
  method poll (line 155) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...
  type ConnectedAddr (line 176) | pub struct ConnectedAddr {
    method from (line 182) | fn from(multiaddr: &Multiaddr) -> Self {

FILE: core/network/src/compression/snappy.rs
  type Snappy (line 8) | pub struct Snappy;
  method compress (line 11) | fn compress(&self, bytes: Bytes) -> Result<Bytes, NetworkError> {
  method decompress (line 28) | fn decompress(&self, bytes: Bytes) -> Result<Bytes, NetworkError> {

FILE: core/network/src/config.rs
  constant DEFAULT_LISTEN_IP_ADDR (line 29) | pub const DEFAULT_LISTEN_IP_ADDR: IpAddr = IpAddr::V4(Ipv4Addr::new(0, 0...
  constant DEFAULT_LISTEN_PORT (line 30) | pub const DEFAULT_LISTEN_PORT: u16 = 2337;
  constant DEFAULT_MAX_CONNECTIONS (line 32) | pub const DEFAULT_MAX_CONNECTIONS: usize = 40;
  constant DEFAULT_MAX_FRAME_LENGTH (line 34) | pub const DEFAULT_MAX_FRAME_LENGTH: usize = 4 * 1024 * 1024;
  constant DEFAULT_BUFFER_SIZE (line 35) | pub const DEFAULT_BUFFER_SIZE: usize = 24 * 1024 * 1024;
  constant DEFAULT_MAX_WAIT_STREAMS (line 38) | pub const DEFAULT_MAX_WAIT_STREAMS: usize = 256;
  constant DEFAULT_WRITE_TIMEOUT (line 40) | pub const DEFAULT_WRITE_TIMEOUT: u64 = 10;
  constant DEFAULT_SAME_IP_CONN_LIMIT (line 42) | pub const DEFAULT_SAME_IP_CONN_LIMIT: usize = 1;
  constant DEFAULT_INBOUND_CONN_LIMIT (line 43) | pub const DEFAULT_INBOUND_CONN_LIMIT: usize = 20;
  constant DEFAULT_PEER_TRUST_INTERVAL_DURATION (line 46) | pub const DEFAULT_PEER_TRUST_INTERVAL_DURATION: Duration = Duration::fro...
  constant DEFAULT_PEER_TRUST_MAX_HISTORY_DURATION (line 47) | pub const DEFAULT_PEER_TRUST_MAX_HISTORY_DURATION: Duration =
  constant DEFAULT_PEER_FATAL_BAN_DURATION (line 49) | const DEFAULT_PEER_FATAL_BAN_DURATION: Duration = Duration::from_secs(60...
  constant DEFAULT_PEER_SOFT_BAN_DURATION (line 50) | const DEFAULT_PEER_SOFT_BAN_DURATION: Duration = Duration::from_secs(60 ...
  constant DEFAULT_PEER_FILE_NAME (line 53) | pub const DEFAULT_PEER_FILE_NAME: &str = "peers";
  constant DEFAULT_PEER_FILE_EXT (line 54) | pub const DEFAULT_PEER_FILE_EXT: &str = "dat";
  constant DEFAULT_PEER_DAT_FILE (line 55) | pub const DEFAULT_PEER_DAT_FILE: &str = "./peers.dat";
  constant DEFAULT_PING_INTERVAL (line 57) | pub const DEFAULT_PING_INTERVAL: u64 = 15;
  constant DEFAULT_PING_TIMEOUT (line 58) | pub const DEFAULT_PING_TIMEOUT: u64 = 30;
  constant DEFAULT_DISCOVERY_SYNC_INTERVAL (line 59) | pub const DEFAULT_DISCOVERY_SYNC_INTERVAL: u64 = 60 * 60;
  constant DEFAULT_PEER_MANAGER_HEART_BEAT_INTERVAL (line 61) | pub const DEFAULT_PEER_MANAGER_HEART_BEAT_INTERVAL: u64 = 30;
  constant DEFAULT_SELF_HEART_BEAT_INTERVAL (line 62) | pub const DEFAULT_SELF_HEART_BEAT_INTERVAL: u64 = 35;
  constant DEFAULT_RPC_TIMEOUT (line 64) | pub const DEFAULT_RPC_TIMEOUT: u64 = 10;
  constant DEFAULT_SELF_CHECK_INTERVAL (line 67) | pub const DEFAULT_SELF_CHECK_INTERVAL: u64 = 30;
  type PrivateKeyHexStr (line 69) | pub type PrivateKeyHexStr = String;
  type PeerAddrStr (line 70) | pub type PeerAddrStr = String;
  type PeerIdBase58Str (line 71) | pub type PeerIdBase58Str = String;
  type DnsAddr (line 75) | struct DnsAddr {
  type Err (line 81) | type Err = NetworkError;
  method from_str (line 83) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  method from (line 104) | fn from(addr: DnsAddr) -> Self {
  type NetworkConfig (line 110) | pub struct NetworkConfig {
    method new (line 153) | pub fn new() -> Self {
    method max_connections (line 196) | pub fn max_connections(mut self, max: Option<usize>) -> ProtocolResult...
    method same_ip_conn_limit (line 208) | pub fn same_ip_conn_limit(mut self, limit: Option<usize>) -> Self {
    method inbound_conn_limit (line 216) | pub fn inbound_conn_limit(mut self, limit: Option<usize>) -> ProtocolR...
    method max_frame_length (line 228) | pub fn max_frame_length(mut self, max: Option<usize>) -> Self {
    method send_buffer_size (line 236) | pub fn send_buffer_size(mut self, size: Option<usize>) -> Self {
    method recv_buffer_size (line 244) | pub fn recv_buffer_size(mut self, size: Option<usize>) -> Self {
    method max_wait_streams (line 252) | pub fn max_wait_streams(mut self, max: Option<usize>) -> Self {
    method write_timeout (line 260) | pub fn write_timeout(mut self, timeout: Option<u64>) -> Self {
    method bootstraps (line 268) | pub fn bootstraps(
    method allowlist (line 301) | pub fn allowlist<S: AsRef<[String]>>(mut self, peer_id_strs: S) -> Pro...
    method allowlist_only (line 312) | pub fn allowlist_only(mut self, flag: Option<bool>) -> Self {
    method peer_dat_file (line 319) | pub fn peer_dat_file<P: AsRef<Path>>(mut self, path: P) -> Self {
    method peer_trust_metric (line 329) | pub fn peer_trust_metric(
    method peer_fatal_ban (line 349) | pub fn peer_fatal_ban(mut self, duration: Option<u64>) -> Self {
    method peer_soft_ban (line 357) | pub fn peer_soft_ban(mut self, duration: Option<u64>) -> Self {
    method secio_keypair (line 365) | pub fn secio_keypair(mut self, sk_hex: PrivateKeyHexStr) -> ProtocolRe...
    method ping_interval (line 377) | pub fn ping_interval(mut self, interval: Option<u64>) -> Self {
    method ping_timeout (line 385) | pub fn ping_timeout(mut self, timeout: u64) -> Self {
    method discovery_sync_interval (line 391) | pub fn discovery_sync_interval(mut self, interval: u64) -> Self {
    method peer_manager_heart_beat_interval (line 397) | pub fn peer_manager_heart_beat_interval(mut self, interval: u64) -> Se...
    method heart_beat_interval (line 403) | pub fn heart_beat_interval(mut self, interval: u64) -> Self {
    method rpc_timeout (line 409) | pub fn rpc_timeout(mut self, timeout: Option<u64>) -> Self {
    method selfcheck_interval (line 417) | pub fn selfcheck_interval(mut self, interval: Option<u64>) -> Self {
    method parse_peer_addr (line 425) | fn parse_peer_addr(addr: PeerAddrStr) -> ProtocolResult<Multiaddr> {
  method default (line 437) | fn default() -> Self {
  method from (line 443) | fn from(config: &NetworkConfig) -> ConnectionConfig {
  method from (line 456) | fn from(config: &NetworkConfig) -> PeerManagerConfig {
  type TimeoutConfig (line 480) | pub struct TimeoutConfig {
    method from (line 485) | fn from(config: &NetworkConfig) -> TimeoutConfig {
  method from (line 493) | fn from(config: &NetworkConfig) -> SelfCheckConfig {

FILE: core/network/src/connection/control.rs
  type ProtocolMessage (line 8) | pub struct ProtocolMessage {
  type ConnectionServiceControl (line 16) | pub struct ConnectionServiceControl {
    method new (line 21) | pub fn new(control: ServiceControl) -> Self {
    method send (line 25) | pub fn send(&self, message: ProtocolMessage) -> Result<(), SendErrorKi...

FILE: core/network/src/connection/keeper.rs
  type ConnectionServiceKeeper (line 40) | pub struct ConnectionServiceKeeper {
    method new (line 48) | pub fn new(
    method is_sys_shutdown (line 60) | fn is_sys_shutdown(&self) -> bool {
    method sys_shutdown (line 64) | fn sys_shutdown(&self) {
    method report_error (line 68) | fn report_error(&self, kind: ErrorKind) {
    method report_peer (line 82) | fn report_peer(&self, event: PeerManagerEvent) {
    method process_dailer_error (line 88) | fn process_dailer_error(&self, addr: Multiaddr, error: DialerErrorKind) {
    method process_listen_error (line 115) | fn process_listen_error(&self, addr: Multiaddr, error: ListenErrorKind) {
  method handle_error (line 135) | fn handle_error(&mut self, _ctx: &mut ServiceContext, err: ServiceError) {
  method handle_event (line 214) | fn handle_event(&mut self, ctx: &mut ServiceContext, evt: ServiceEvent) {

FILE: core/network/src/connection/mod.rs
  type ConnectionConfig (line 27) | pub struct ConnectionConfig {
  type ConnectionService (line 47) | pub struct ConnectionService<P: NetworkProtocol> {
  function new (line 59) | pub fn new(
  function listen (line 108) | pub async fn listen(&mut self, address: Multiaddr) -> Result<(), Network...
  function control (line 114) | pub fn control(&self) -> ConnectionServiceControl {
  function process_event (line 122) | pub fn process_event(&mut self, event: ConnectionEvent) {
  type Output (line 180) | type Output = ();
  method poll (line 182) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...

FILE: core/network/src/endpoint.rs
  constant GOSSIP_SCHEME (line 12) | pub const GOSSIP_SCHEME: &str = "/gossip";
  constant RPC_CALL_SCHEME (line 13) | pub const RPC_CALL_SCHEME: &str = "/rpc_call";
  constant RPC_RESPONSE_SCHEME (line 14) | pub const RPC_RESPONSE_SCHEME: &str = "/rpc_resp";
  constant MAX_ENDPOINT_LENGTH (line 16) | pub const MAX_ENDPOINT_LENGTH: usize = 120;
  type EndpointScheme (line 19) | pub enum EndpointScheme {
  type Endpoint (line 39) | pub struct Endpoint(String);
    method starts_with (line 42) | pub fn starts_with(&self, pat: &str) -> bool {
    method scheme (line 46) | pub fn scheme(&self) -> EndpointScheme {
    method root (line 59) | pub fn root(&self) -> String {
    method full_url (line 70) | pub fn full_url(&self) -> &str {
    method extend (line 74) | pub fn extend(&self, comp: &str) -> Result<Self, NetworkError> {
  method eq (line 82) | fn eq(&self, other: &Self) -> bool {
  method hash (line 90) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Err (line 96) | type Err = NetworkError;
  method from_str (line 98) | fn from_str(end: &str) -> Result<Self, Self::Err> {
  type RpcId (line 128) | pub struct RpcId(u64);
    method value (line 131) | pub fn value(self) -> u64 {
  type RpcEndpoint (line 138) | pub struct RpcEndpoint {
    method endpoint (line 144) | pub fn endpoint(&self) -> &Endpoint {
    method rpc_id (line 148) | pub fn rpc_id(&self) -> RpcId {
    method extract_rpc_id_from (line 152) | fn extract_rpc_id_from(end: &Endpoint) -> Result<RpcId, NetworkError> {
    type Error (line 173) | type Error = NetworkError;
    method try_from (line 175) | fn try_from(end: Endpoint) -> Result<Self, Self::Error> {
  type Err (line 183) | type Err = NetworkError;
  method from_str (line 185) | fn from_str(end: &str) -> Result<Self, Self::Err> {
  function should_able_parse_valid_endpoint_url (line 203) | fn should_able_parse_valid_endpoint_url() {

FILE: core/network/src/error.rs
  type ErrorKind (line 15) | pub enum ErrorKind {
  type PeerIdNotFound (line 85) | pub struct PeerIdNotFound(pub(crate) Multiaddr);
  type NetworkError (line 90) | pub enum NetworkError {
    method from (line 162) | fn from(err: PeerIdNotFound) -> NetworkError {
    method from (line 168) | fn from(kind: ErrorKind) -> NetworkError {
    method from (line 174) | fn from(kind: Box<bincode::ErrorKind>) -> NetworkError {
    method from (line 186) | fn from(err: std::io::Error) -> NetworkError {
    method from (line 192) | fn from(err: tentacle::error::TransportErrorKind) -> NetworkError {
    method boxed (line 204) | pub fn boxed(self) -> Box<dyn Error + Send> {
  method from (line 180) | fn from(err: NetworkError) -> ProtocolError {
  function from (line 198) | fn from(err: NetworkError) -> Box<dyn Error + Send> {

FILE: core/network/src/event.rs
  type ConnectionEvent (line 19) | pub enum ConnectionEvent {
  type ProtocolIdentity (line 31) | pub enum ProtocolIdentity {
  type ConnectionErrorKind (line 39) | pub enum ConnectionErrorKind {
    method from (line 63) | fn from(err: TransportErrorKind) -> ConnectionErrorKind {
  type SessionErrorKind (line 77) | pub enum SessionErrorKind {
  type MisbehaviorKind (line 95) | pub enum MisbehaviorKind {
  type ConnectionType (line 108) | pub enum ConnectionType {
  type PeerManagerEvent (line 117) | pub enum PeerManagerEvent {

FILE: core/network/src/lib.rs
  type PeerIdExt (line 34) | pub trait PeerIdExt {
    method from_pubkey_bytes (line 35) | fn from_pubkey_bytes<'a, B: AsRef<[u8]> + 'a>(bytes: B) -> Result<Peer...
    method from_bytes (line 42) | fn from_bytes<'a, B: AsRef<[u8]> + 'a>(bytes: B) -> Result<PeerId, Net...
    method to_string (line 46) | fn to_string(&self) -> String;
    method into_bytes_ext (line 48) | fn into_bytes_ext(self) -> Bytes;
    method from_str_ext (line 50) | fn from_str_ext<'a, S: AsRef<str> + 'a>(s: S) -> Result<PeerId, Networ...
    method into_bytes_ext (line 56) | fn into_bytes_ext(self) -> Bytes {
    method to_string (line 60) | fn to_string(&self) -> String {

FILE: core/network/src/message/mod.rs
  type Headers (line 13) | pub struct Headers(HashMap<String, Vec<u8>>);
    method set_trace_id (line 22) | pub fn set_trace_id(&mut self, id: TraceId) {
    method set_span_id (line 27) | pub fn set_span_id(&mut self, id: u64) {
  method default (line 16) | fn default() -> Self {
  type NetworkMessage (line 34) | pub struct NetworkMessage {
    method new (line 46) | pub fn new(endpoint: Endpoint, content: Bytes, headers: Headers) -> Se...
    method trace_id (line 54) | pub fn trace_id(&self) -> Option<TraceId> {
    method span_id (line 66) | pub fn span_id(&self) -> Option<u64> {
    method encode (line 74) | pub fn encode(self) -> Result<Bytes, NetworkError> {
    method decode (line 83) | pub fn decode(bytes: Bytes) -> Result<Self, NetworkError> {
  type Hashes (line 95) | struct Hashes {
    method from (line 116) | fn from(q_hashes: Vec<QHash>) -> Hashes {
  type QHash (line 101) | struct QHash {
    method arbitrary (line 107) | fn arbitrary<G: quickcheck::Gen>(g: &mut G) -> QHash {
  function prop_protocol_type_serialization (line 127) | fn prop_protocol_type_serialization(hash: QHash) -> bool {
  function prop_vec_protocol_type_serialization (line 132) | fn prop_vec_protocol_type_serialization(hashes: Vec<QHash>) -> bool {

FILE: core/network/src/message/serde.rs
  function serialize (line 7) | pub fn serialize<T, S>(val: &T, s: S) -> Result<S::Ok, S::Error>
  type BytesVisit (line 17) | struct BytesVisit;
    type Value (line 30) | type Value = Bytes;
    method expecting (line 32) | fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
    method visit_byte_buf (line 37) | fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
  function deserialize (line 19) | pub fn deserialize<'de, T, D>(deserializer: D) -> Result<T, D::Error>

FILE: core/network/src/message/serde_multi.rs
  type TWrapper (line 9) | struct TWrapper<T: ProtocolCodecSync> {
  type VecT (line 15) | struct VecT<T: ProtocolCodecSync> {
  function serialize (line 19) | pub fn serialize<'se, V, T, S>(val: &'se V, s: S) -> Result<S::Ok, S::Er...
  function deserialize (line 37) | pub fn deserialize<'de, T, V, D>(deserializer: D) -> Result<V, D::Error>

FILE: core/network/src/metrics.rs
  constant METRICS_INTERVAL (line 16) | const METRICS_INTERVAL: Duration = Duration::from_secs(1);
  type Metrics (line 18) | pub(crate) struct Metrics<S> {
  function new (line 28) | pub fn new(sessions: S) -> Self {
  function report_pending_data (line 39) | fn report_pending_data(&self) {
  type Output (line 65) | type Output = ();
  method poll (line 67) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...

FILE: core/network/src/outbound/gossip.rs
  type NetworkGossip (line 15) | pub struct NetworkGossip {
    method new (line 20) | pub fn new(transmitter: Transmitter) -> Self {
    method package_message (line 24) | async fn package_message<M>(
    method send_to_sessions (line 47) | async fn send_to_sessions(
    method send_to_peers (line 64) | async fn send_to_peers<'a, P: AsRef<[Bytes]> + 'a>(
  method broadcast (line 91) | async fn broadcast<M>(
  method multicast (line 109) | async fn multicast<'a, M, P>(

FILE: core/network/src/outbound/rpc.rs
  type NetworkRpc (line 20) | pub struct NetworkRpc {
    method new (line 26) | pub fn new(transmitter: Transmitter, timeout: TimeoutConfig) -> Self {
    method send (line 33) | async fn send(
  method call (line 55) | async fn call<M, R>(
  method response (line 137) | async fn response<M>(

FILE: core/network/src/peer_manager/addr_set.rs
  constant MAX_ADDR_FAILURE (line 16) | const MAX_ADDR_FAILURE: u8 = MAX_RETRY_COUNT;
  type AddrInfo (line 19) | struct AddrInfo {
    method owned_addr (line 25) | pub fn owned_addr(&self) -> PeerMultiaddr {
    method owned_raw_addr (line 29) | pub fn owned_raw_addr(&self) -> Multiaddr {
    method failure (line 34) | pub fn failure(&self) -> usize {
    method inc_failure (line 38) | pub fn inc_failure(&self) {
    method give_up (line 42) | pub fn give_up(&self) {
    method reset_failure (line 47) | pub fn reset_failure(&self) {
    method connectable (line 51) | pub fn connectable(&self) -> bool {
    method from (line 65) | fn from(pma: PeerMultiaddr) -> AddrInfo {
    method borrow (line 74) | fn borrow(&self) -> &PeerMultiaddr {
  type Target (line 57) | type Target = PeerMultiaddr;
  method deref (line 59) | fn deref(&self) -> &Self::Target {
  method eq (line 80) | fn eq(&self, other: &Self) -> bool {
  method hash (line 88) | fn hash<H: Hasher>(&self, state: &mut H) {
  type PeerAddrSet (line 94) | pub struct PeerAddrSet {
    method new (line 100) | pub fn new(peer_id: PeerId) -> Self {
    method insert (line 107) | pub fn insert(&self, multiaddrs: Vec<PeerMultiaddr>) {
    method set (line 122) | pub fn set(&self, multiaddrs: Vec<PeerMultiaddr>) {
    method insert_raw (line 132) | pub(crate) fn insert_raw(&self, multiaddr: Multiaddr) {
    method remove (line 142) | pub fn remove(&self, multiaddr: &PeerMultiaddr) {
    method contains (line 146) | pub fn contains(&self, multiaddr: &PeerMultiaddr) -> bool {
    method all (line 150) | pub fn all(&self) -> Vec<PeerMultiaddr> {
    method all_raw (line 154) | pub fn all_raw(&self) -> Vec<Multiaddr> {
    method connectable (line 162) | pub fn connectable(&self) -> Vec<PeerMultiaddr> {
    method len (line 174) | pub fn len(&self) -> usize {
    method connectable_len (line 178) | pub fn connectable_len(&self) -> usize {
    method failure (line 183) | pub fn failure(&self, pma: &PeerMultiaddr) -> Option<usize> {
    method inc_failure (line 187) | pub fn inc_failure(&self, pma: &PeerMultiaddr) {
    method give_up (line 193) | pub fn give_up(&self, pma: &PeerMultiaddr) {
    method reset_failure (line 199) | pub fn reset_failure(&self, pma: &PeerMultiaddr) {
    method match_peer_id (line 205) | fn match_peer_id(&self, pma: &PeerMultiaddr) -> bool {

FILE: core/network/src/peer_manager/diagnostic.rs
  type NotFound (line 12) | pub struct NotFound {}
  type DiagnosticEvent (line 16) | pub enum DiagnosticEvent {
  function from (line 34) | fn from(event: &PeerManagerEvent) -> Self {
  type DiagnosticHookFn (line 48) | pub type DiagnosticHookFn = Box<dyn Fn(DiagnosticEvent) + Send + 'static>;
  type TrustReport (line 58) | pub struct TrustReport {
  type Diagnostic (line 66) | pub struct Diagnostic(Arc<Inner>);
    method new (line 69) | pub(super) fn new(inner: Arc<Inner>) -> Self {
    method session (line 73) | pub fn session(&self, peer_id: &PeerId) -> Option<SessionId> {
    method new_trust_interval (line 80) | pub fn new_trust_interval(&self, sid: SessionId) -> Result<TrustReport...

FILE: core/network/src/peer_manager/mod.rs
  constant SAME_IP_LIMIT_BAN (line 69) | const SAME_IP_LIMIT_BAN: Duration = Duration::from_secs(5 * 60);
  constant REPEATED_CONNECTION_TIMEOUT (line 70) | const REPEATED_CONNECTION_TIMEOUT: u64 = 30;
  constant BACKOFF_BASE (line 71) | const BACKOFF_BASE: u64 = 2;
  constant MAX_RETRY_INTERVAL (line 72) | const MAX_RETRY_INTERVAL: u64 = 512;
  constant MAX_RETRY_COUNT (line 73) | const MAX_RETRY_COUNT: u8 = 30;
  constant SHORT_ALIVE_SESSION (line 74) | const SHORT_ALIVE_SESSION: u64 = 3;
  constant MAX_CONNECTING_MARGIN (line 75) | const MAX_CONNECTING_MARGIN: usize = 10;
  constant MAX_RANDOM_NEXT_RETRY (line 76) | const MAX_RANDOM_NEXT_RETRY: u64 = 10;
  constant MAX_CONNECTING_TIMEOUT (line 77) | const MAX_CONNECTING_TIMEOUT: Duration = Duration::from_secs(30);
  constant GOOD_TRUST_SCORE (line 79) | const GOOD_TRUST_SCORE: u8 = 80u8;
  constant WORSE_TRUST_SCALAR_RATIO (line 80) | const WORSE_TRUST_SCALAR_RATIO: usize = 10;
  type NewSessionPreCheckError (line 83) | pub enum NewSessionPreCheckError {
  type PeerMultiaddr (line 102) | pub struct PeerMultiaddr(Multiaddr);
    method new (line 105) | pub fn new(mut ma: Multiaddr, peer_id: &PeerId) -> Self {
    method peer_id (line 113) | pub fn peer_id(&self) -> PeerId {
    method extract_id (line 117) | fn extract_id(ma: &Multiaddr) -> Option<PeerId> {
    method borrow (line 130) | fn borrow(&self) -> &Multiaddr {
    type Error (line 158) | type Error = PeerIdNotFound;
    method try_from (line 160) | fn try_from(ma: Multiaddr) -> Result<PeerMultiaddr, Self::Error> {
    method into (line 170) | fn into(self) -> Multiaddr {
  method eq (line 136) | fn eq(&self, other: &PeerMultiaddr) -> bool {
  method hash (line 144) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Target (line 150) | type Target = Multiaddr;
  method deref (line 152) | fn deref(&self) -> &Self::Target {
  type ConnectingAttempt (line 176) | struct ConnectingAttempt {
    method new (line 183) | fn new(peer: ArcPeer) -> Self {
    method multiaddrs (line 194) | fn multiaddrs(&self) -> usize {
    method complete_one_multiaddr (line 198) | fn complete_one_multiaddr(&mut self, multiaddr: &PeerMultiaddr) {
    method is_timeout (line 202) | fn is_timeout(&self) -> bool {
    method set_at (line 207) | fn set_at(&mut self, duration: Duration) {
    method borrow (line 213) | fn borrow(&self) -> &PeerId {
  method eq (line 219) | fn eq(&self, other: &ConnectingAttempt) -> bool {
  method hash (line 227) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Inner (line 232) | struct Inner {
    method new (line 244) | pub fn new(our_id: PeerId, sessions: SessionBook) -> Self {
    method add_listen (line 257) | pub fn add_listen(&self, multiaddr: PeerMultiaddr) {
    method listen (line 261) | pub fn listen(&self) -> HashSet<PeerMultiaddr> {
    method remove_listen (line 265) | pub fn remove_listen(&self, multiaddr: &PeerMultiaddr) {
    method set_chain_id (line 269) | pub fn set_chain_id(&self, chain_id: protocol::types::Hash) {
    method chain_id (line 273) | pub fn chain_id(&self) -> Arc<protocol::types::Hash> {
    method connected (line 277) | pub fn connected(&self) -> usize {
    method add_peer (line 282) | pub fn add_peer(&self, peer: ArcPeer) -> bool {
    method peer_count (line 287) | pub fn peer_count(&self) -> usize {
    method peer (line 291) | pub fn peer(&self, peer_id: &PeerId) -> Option<ArcPeer> {
    method contains (line 295) | pub fn contains(&self, peer_id: &PeerId) -> bool {
    method connectable_peers (line 299) | pub fn connectable_peers<F>(&self, max: usize, addition_filter: F) -> ...
    method session (line 319) | pub fn session(&self, sid: SessionId) -> Option<ArcSession> {
    method share_sessions (line 323) | pub fn share_sessions(&self) -> Vec<ArcSession> {
    method remove_session (line 327) | pub fn remove_session(&self, sid: SessionId) -> Option<ArcSession> {
    method package_peers (line 331) | pub fn package_peers(&self) -> Vec<ArcPeer> {
    method restore (line 335) | fn restore(&self, peers: Vec<ArcPeer>) {
    method outbound_count (line 339) | fn outbound_count(&self) -> usize {
  type UnidentifiedSessionEvent (line 344) | struct UnidentifiedSessionEvent {
  type UnidentifiedSession (line 349) | struct UnidentifiedSession {
    method new (line 356) | fn new(event: UnidentifiedSessionEvent, ident_fut: WaitIdentification)...
    method peer_id (line 364) | fn peer_id(&self) -> PeerId {
    method borrow (line 370) | fn borrow(&self) -> &SessionId {
  method eq (line 376) | fn eq(&self, other: &UnidentifiedSession) -> bool {
  method hash (line 384) | fn hash<H: Hasher>(&self, state: &mut H) {
  type PeerManagerConfig (line 390) | pub struct PeerManagerConfig {
  type PeerManagerHandle (line 430) | pub struct PeerManagerHandle {
    method peer_id (line 435) | pub fn peer_id(&self, sid: SessionId) -> Option<PeerId> {
    method set_chain_id (line 439) | pub fn set_chain_id(&self, chain_id: protocol::types::Hash) {
    method chain_id (line 443) | pub fn chain_id(&self) -> Arc<protocol::types::Hash> {
    method contains_session (line 447) | pub fn contains_session(&self, session_id: SessionId) -> bool {
    method random_addrs (line 451) | pub fn random_addrs(&self, max: usize, sid: SessionId) -> Vec<Multiadd...
    method listen_addrs (line 488) | pub fn listen_addrs(&self) -> Vec<Multiaddr> {
    method tag (line 503) | pub fn tag(&self, peer_id: &PeerId, tag: PeerTag) -> Result<(), Networ...
    method untag (line 521) | pub fn untag(&self, peer_id: &PeerId, tag: &PeerTag) {
    method tag_consensus (line 531) | pub fn tag_consensus(&self, peer_ids: Vec<PeerId>) {
  type PeerManager (line 553) | pub struct PeerManager {
    method new (line 582) | pub fn new(
    method handle (line 628) | pub fn handle(&self) -> PeerManagerHandle {
    method share_session_book (line 634) | pub fn share_session_book(&self, config: shared::Config) -> SharedSess...
    method register_diagnostic_hook (line 639) | pub fn register_diagnostic_hook(&mut self, f: diagnostic::DiagnosticHo...
    method diagnostic (line 644) | pub fn diagnostic(&self) -> diagnostic::Diagnostic {
    method enable_save_restore (line 648) | pub fn enable_save_restore(&mut self) {
    method restore_peers (line 654) | pub fn restore_peers(&self) -> Result<(), NetworkError> {
    method bootstrap (line 660) | pub fn bootstrap(&mut self) {
    method disconnect_session (line 676) | pub fn disconnect_session(&self, sid: SessionId) {
    method inner (line 684) | fn inner(&self) -> Arc<Inner> {
    method config (line 689) | fn config(&self) -> PeerManagerConfig {
    method set_connecting (line 694) | fn set_connecting(&mut self, peers: Vec<ArcPeer>) {
    method new_session_pre_check (line 700) | fn new_session_pre_check(
    method new_unidentified_session (line 835) | fn new_unidentified_session(&mut self, pubkey: PublicKey, ctx: Arc<Ses...
    method new_session (line 852) | fn new_session(&mut self, pubkey: PublicKey, ctx: Arc<SessionContext>) {
    method session_closed (line 894) | fn session_closed(&mut self, pid: PeerId, sid: SessionId) {
    method connect_failed (line 976) | fn connect_failed(&mut self, addr: Multiaddr, error_kind: ConnectionEr...
    method session_failed (line 1053) | fn session_failed(&self, sid: SessionId, error_kind: SessionErrorKind) {
    method update_peer_alive (line 1093) | fn update_peer_alive(&self, pid: &PeerId) {
    method peer_misbehave (line 1107) | fn peer_misbehave(&self, pid: PeerId, kind: MisbehaviorKind) {
    method trust_metric_feedback (line 1153) | fn trust_metric_feedback(&self, pid: PeerId, feedback: TrustFeedback) {
    method session_blocked (line 1236) | fn session_blocked(&self, ctx: Arc<SessionContext>) {
    method connect_peers_now (line 1261) | fn connect_peers_now(&mut self, peers: Vec<ArcPeer>) {
    method connect_peers (line 1284) | fn connect_peers(&mut self, peers: Vec<ArcPeer>) {
    method connect_peers_by_id (line 1325) | fn connect_peers_by_id(&mut self, pids: Vec<PeerId>) {
    method discover_multiaddr (line 1337) | fn discover_multiaddr(&mut self, addr: Multiaddr) {
    method dicover_multi_multiaddrs (line 1359) | fn dicover_multi_multiaddrs(&mut self, addrs: Vec<Multiaddr>) {
    method identified_addrs (line 1365) | fn identified_addrs(&self, pid: &PeerId, addrs: Vec<Multiaddr>) {
    method repeated_connection (line 1379) | fn repeated_connection(&mut self, ty: ConnectionType, sid: SessionId, ...
    method process_event (line 1413) | fn process_event(&mut self, event: PeerManagerEvent) {
  method drop (line 1452) | fn drop(&mut self) {
  type Output (line 1462) | type Output = ();
  method poll (line 1464) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...

FILE: core/network/src/peer_manager/peer.rs
  type Connectedness (line 27) | pub enum Connectedness {
    method from (line 45) | fn from(src: usize) -> Connectedness {
  function from (line 60) | fn from(src: Connectedness) -> usize {
  type Peer (line 66) | pub struct Peer {
    method new (line 81) | pub fn new(peer_id: PeerId) -> Self {
    method from_pubkey (line 97) | pub fn from_pubkey(pubkey: PublicKey) -> Result<Self, ErrorKind> {
    method owned_id (line 104) | pub fn owned_id(&self) -> PeerId {
    method has_pubkey (line 108) | pub fn has_pubkey(&self) -> bool {
    method owned_pubkey (line 112) | pub fn owned_pubkey(&self) -> Option<PublicKey> {
    method set_pubkey (line 116) | pub fn set_pubkey(&self, pubkey: PublicKey) -> Result<(), ErrorKind> {
    method trust_metric (line 128) | pub fn trust_metric(&self) -> Option<TrustMetric> {
    method set_trust_metric (line 132) | pub fn set_trust_metric(&self, metric: TrustMetric) {
    method remove_trust_metric (line 137) | pub fn remove_trust_metric(&self) {
    method connectedness (line 141) | pub fn connectedness(&self) -> Connectedness {
    method set_connectedness (line 145) | pub fn set_connectedness(&self, flag: Connectedness) {
    method set_session_id (line 150) | pub fn set_session_id(&self, sid: SessionId) {
    method session_id (line 154) | pub fn session_id(&self) -> SessionId {
    method connected_at (line 158) | pub fn connected_at(&self) -> u64 {
    method set_connected_at (line 162) | pub(super) fn set_connected_at(&self, at: u64) {
    method disconnected_at (line 166) | pub fn disconnected_at(&self) -> u64 {
    method set_disconnected_at (line 170) | pub(super) fn set_disconnected_at(&self, at: u64) {
    method alive (line 174) | pub fn alive(&self) -> u64 {
    method update_alive (line 178) | pub fn update_alive(&self) {
    method set_alive (line 186) | pub(super) fn set_alive(&self, live: u64) {
    method mark_connected (line 190) | pub fn mark_connected(&self, sid: SessionId) {
    method mark_disconnected (line 197) | pub fn mark_disconnected(&self) {
    method banned (line 204) | pub fn banned(&self) -> bool {
    method update_connected (line 221) | fn update_connected(&self) {
    method update_disconnected (line 225) | fn update_disconnected(&self) {
    method fmt (line 231) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ArcPeer (line 248) | pub struct ArcPeer(Arc<Peer>);
    method new (line 251) | pub fn new(peer_id: PeerId) -> Self {
    method from_pubkey (line 255) | pub fn from_pubkey(pubkey: PublicKey) -> Result<Self, ErrorKind> {
    method borrow (line 269) | fn borrow(&self) -> &PeerId {
  type Target (line 261) | type Target = Peer;
  method deref (line 263) | fn deref(&self) -> &Self::Target {
  method eq (line 275) | fn eq(&self, other: &ArcPeer) -> bool {
  method hash (line 283) | fn hash<H: Hasher>(&self, state: &mut H) {
  function should_reset_trust_metric_history_after_unban (line 298) | fn should_reset_trust_metric_history_after_unban() {
  function should_be_able_to_convert_between_connectedness_and_usize (line 323) | fn should_be_able_to_convert_between_connectedness_and_usize() {

FILE: core/network/src/peer_manager/retry.rs
  type Retry (line 10) | pub struct Retry {
    method new (line 17) | pub fn new(max: u8) -> Self {
    method inc (line 25) | pub fn inc(&self) {
    method eta (line 37) | pub fn eta(&self) -> u64 {
    method reset (line 42) | pub fn reset(&self) {
    method ready (line 46) | pub fn ready(&self) -> bool {
    method count (line 52) | pub fn count(&self) -> u8 {
    method next_attempt_at (line 56) | pub fn next_attempt_at(&self) -> u64 {
    method run_out (line 60) | pub fn run_out(&self) -> bool {
    method set_next_attempt_at (line 65) | pub(crate) fn set_next_attempt_at(&self, at: u64) {
    method set (line 70) | pub(crate) fn set(&self, n: u8) {

FILE: core/network/src/peer_manager/save_restore.rs
  type SerdePeer (line 23) | struct SerdePeer {
    method from (line 38) | fn from(peer: ArcPeer) -> SerdePeer {
  type Error (line 59) | type Error = NetworkError;
  method try_from (line 61) | fn try_from(serde_peer: SerdePeer) -> Result<Self, Self::Error> {
  type SaveRestore (line 92) | pub(super) trait SaveRestore: Send + Sync {
    method save (line 93) | fn save(&self, peers: Vec<ArcPeer>) -> Result<(), NetworkError>;
    method restore (line 94) | fn restore(&self) -> Result<Vec<ArcPeer>, NetworkError>;
    method save (line 111) | fn save(&self, peers: Vec<ArcPeer>) -> Result<(), NetworkError> {
    method restore (line 121) | fn restore(&self) -> Result<Vec<ArcPeer>, NetworkError> {
    method save (line 144) | fn save(&self, _peers: Vec<ArcPeer>) -> Result<(), NetworkError> {
    method restore (line 148) | fn restore(&self) -> Result<Vec<ArcPeer>, NetworkError> {
  type PeerDatFile (line 98) | pub(super) struct PeerDatFile {
    method new (line 103) | pub fn new<P: AsRef<Path>>(path: P) -> Self {
  type NoPeerDatFile (line 141) | pub(super) struct NoPeerDatFile;
  type SerdePubKey (line 154) | pub struct SerdePubKey(PublicKey);
    method serialize (line 157) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    method deserialize (line 166) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  type SerdePeerId (line 205) | pub struct SerdePeerId(PeerId);
    method serialize (line 208) | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    method deserialize (line 217) | fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

FILE: core/network/src/peer_manager/session_book.rs
  type Host (line 24) | type Host = String;
  type Count (line 25) | type Count = usize;
  type Error (line 28) | pub enum Error {
  type Config (line 40) | pub struct Config {
    method from (line 57) | fn from(config: &PeerManagerConfig) -> Config {
  method default (line 47) | fn default() -> Self {
  type Session (line 67) | pub struct Session {
  type ArcSession (line 76) | pub struct ArcSession(Arc<Session>);
    method new (line 79) | pub fn new(peer: ArcPeer, ctx: Arc<SessionContext>) -> Self {
    method ty (line 92) | pub fn ty(&self) -> SessionType {
    method block (line 96) | pub fn block(&self) {
    method is_blocked (line 100) | pub fn is_blocked(&self) -> bool {
    method unblock (line 104) | pub fn unblock(&self) {
    method borrow (line 110) | fn borrow(&self) -> &SessionId {
  method eq (line 116) | fn eq(&self, other: &ArcSession) -> bool {
  method hash (line 124) | fn hash<H: Hasher>(&self, state: &mut H) {
  type Target (line 130) | type Target = Session;
  method deref (line 132) | fn deref(&self) -> &Self::Target {
  type AcceptableSession (line 137) | pub struct AcceptableSession(pub ArcSession);
  type SessionBook (line 139) | pub struct SessionBook {
    method new (line 158) | pub fn new(config: Config) -> Self {
    method len (line 168) | pub fn len(&self) -> usize {
    method get (line 172) | pub fn get(&self, sid: &SessionId) -> Option<ArcSession> {
    method all (line 176) | pub fn all(&self) -> Vec<ArcSession> {
    method iter_fn (line 180) | pub fn iter_fn<R, F>(&self, f: F) -> R
    method inbound_count (line 188) | pub fn inbound_count(&self) -> usize {
    method outbound_count (line 192) | pub fn outbound_count(&self) -> usize {
    method acceptable (line 196) | pub fn acceptable(&self, session: &ArcSession) -> Result<(), self::Err...
    method insert (line 218) | pub fn insert(&self, AcceptableSession(session): AcceptableSession) {
    method remove (line 235) | pub fn remove(&self, sid: &SessionId) -> Option<ArcSession> {
  method default (line 150) | fn default() -> SessionBook {
  function make_multiaddr (line 275) | fn make_multiaddr(port: u16, id: Option<PeerId>) -> Multiaddr {
  function make_peer_multiaddr (line 287) | fn make_peer_multiaddr(port: u16, id: PeerId) -> PeerMultiaddr {
  function make_peer (line 293) | fn make_peer(port: u16) -> ArcPeer {
  function make_session (line 304) | fn make_session(port: u16, sid: SessionId, ty: SessionType) -> ArcSession {
  function should_reject_session_when_reach_same_ip_conn_limit (line 313) | fn should_reject_session_when_reach_same_ip_conn_limit() {
  function should_reduce_host_count (line 338) | fn should_reduce_host_count() {
  function should_reject_inbound_session_when_reach_inbound_limit (line 360) | fn should_reject_inbound_session_when_reach_inbound_limit() {
  function should_reject_outbound_session_when_reach_outbound_limit (line 386) | fn should_reject_outbound_session_when_reach_outbound_limit() {

FILE: core/network/src/peer_manager/shared.rs
  type Config (line 14) | pub struct Config {
    method from (line 21) | fn from(config: &NetworkConfig) -> Self {
  type SharedSessions (line 30) | pub struct SharedSessions {
    method new (line 36) | pub(super) fn new(inner: Arc<Inner>, config: Config) -> Self {
    method sessions (line 43) | fn sessions(&self) -> &SessionBook {
  method all_sendable (line 49) | fn all_sendable(&self) -> Vec<SessionId> {
  method all_blocked (line 56) | fn all_blocked(&self) -> Vec<SessionId> {
  method refresh_blocked (line 63) | fn refresh_blocked(&self) {
  method peers (line 80) | fn peers(&self, pids: Vec<PeerId>) -> (Vec<SessionId>, Vec<PeerId>) {
  method all (line 96) | fn all(&self) -> Vec<SessionId> {
  method connected_addr (line 100) | fn connected_addr(&self, sid: SessionId) -> Option<ConnectedAddr> {
  method pending_data_size (line 106) | fn pending_data_size(&self, sid: SessionId) -> usize {
  method allowlist (line 113) | fn allowlist(&self) -> Vec<PeerId> {
  method len (line 126) | fn len(&self) -> usize {
  function should_return_unconnected_peer_ids (line 141) | fn should_return_unconnected_peer_ids() {

FILE: core/network/src/peer_manager/tags.rs
  type TagError (line 11) | pub enum TagError {
  method from (line 19) | fn from(err: TagError) -> NetworkError {
  type Tags (line 25) | pub struct Tags(RwLock<HashSet<PeerTag>>);
    method get_banned_until (line 34) | pub fn get_banned_until(&self) -> Option<u64> {
    method insert_ban (line 44) | pub fn insert_ban(&self, timeout: Duration) -> Result<(), TagError> {
    method set_ban_until (line 50) | pub fn set_ban_until(&self, until: u64) {
    method insert (line 54) | pub fn insert(&self, tag: PeerTag) -> Result<(), TagError> {
    method remove (line 65) | pub fn remove(&self, tag: &PeerTag) {
    method contains (line 69) | pub fn contains(&self, tag: &PeerTag) -> bool {
  method default (line 28) | fn default() -> Self {

FILE: core/network/src/peer_manager/test_manager.rs
  function make_multiaddr (line 41) | fn make_multiaddr(port: u16, id: Option<PeerId>) -> Multiaddr {
  function make_peer_multiaddr (line 53) | fn make_peer_multiaddr(port: u16, id: PeerId) -> PeerMultiaddr {
  function make_peer (line 59) | fn make_peer(port: u16) -> ArcPeer {
  function make_bootstraps (line 70) | fn make_bootstraps(num: usize) -> Vec<ArcPeer> {
  type MockManager (line 82) | struct MockManager {
    method new (line 88) | pub fn new(inner: PeerManager, event_tx: UnboundedSender<PeerManagerEv...
    method poll_event (line 92) | pub async fn poll_event(&mut self, event: PeerManagerEvent) {
    method poll (line 97) | pub async fn poll(&mut self) {
    method config (line 101) | pub fn config(&self) -> PeerManagerConfig {
    method connecting (line 105) | pub fn connecting(&self) -> &HashSet<ConnectingAttempt> {
    method connecting_mut (line 109) | pub fn connecting_mut(&mut self) -> &mut HashSet<ConnectingAttempt> {
    method core_inner (line 113) | pub fn core_inner(&self) -> Arc<Inner> {
  type Output (line 119) | type Output = ();
  method poll (line 121) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...
  function make_manager (line 127) | fn make_manager(
  function make_pubkey (line 165) | fn make_pubkey() -> PublicKey {
  function make_sessions (line 170) | async fn make_sessions(
  function should_accept_new_peer_inbound_connection_on_new_session (line 217) | async fn should_accept_new_peer_inbound_connection_on_new_session() {
  function should_accept_outbound_connection_and_remove_mached_connecting_on_new_session (line 259) | async fn should_accept_outbound_connection_and_remove_mached_connecting_...
  function should_set_matched_peer_pubkey_on_new_session (line 299) | async fn should_set_matched_peer_pubkey_on_new_session() {
  function should_reset_outbound_peer_multiaddr_failure_count_on_new_session (line 330) | async fn should_reset_outbound_peer_multiaddr_failure_count_on_new_sessi...
  function should_ignore_inbound_address_on_new_session (line 368) | async fn should_ignore_inbound_address_on_new_session() {
  function should_enforce_id_in_multiaddr_on_new_session (line 400) | async fn should_enforce_id_in_multiaddr_on_new_session() {
  function should_add_new_outbound_multiaddr_to_peer_on_new_session (line 437) | async fn should_add_new_outbound_multiaddr_to_peer_on_new_session() {
  function should_always_remove_inbound_multiaddr_even_if_we_reach_max_connections_on_new_session (line 475) | async fn should_always_remove_inbound_multiaddr_even_if_we_reach_max_con...
  function should_remove_matched_peer_inbound_address_from_ctx_even_if_it_doesnt_have_id_on_new_session (line 512) | async fn should_remove_matched_peer_inbound_address_from_ctx_even_if_it_...
  function should_reject_new_connection_for_same_peer_on_new_session (line 548) | async fn should_reject_new_connection_for_same_peer_on_new_session() {
  function should_keep_new_connection_for_error_outdated_peer_session_on_new_session (line 584) | async fn should_keep_new_connection_for_error_outdated_peer_session_on_n...
  function should_reject_new_connections_when_we_reach_max_connections_on_new_session (line 619) | async fn should_reject_new_connections_when_we_reach_max_connections_on_...
  function should_remove_connecting_even_if_session_is_reject_due_to_reach_max_connections_on_new_session (line 650) | async fn should_remove_connecting_even_if_session_is_reject_due_to_reach...
  function should_reject_banned_peer_on_new_session (line 690) | async fn should_reject_banned_peer_on_new_session() {
  function should_start_trust_metric_on_connected_peer_on_new_session (line 725) | async fn should_start_trust_metric_on_connected_peer_on_new_session() {
  function should_replace_low_quality_peer_with_better_one_due_to_max_connections_on_new_session (line 750) | async fn should_replace_low_quality_peer_with_better_one_due_to_max_conn...
  function should_not_replace_any_peer_if_incoming_hasnt_trust_score_due_to_max_connections_on_new_session (line 806) | async fn should_not_replace_any_peer_if_incoming_hasnt_trust_score_due_t...
  function should_not_replace_any_higher_score_peer_due_to_max_connections_on_new_session (line 855) | async fn should_not_replace_any_higher_score_peer_due_to_max_connections...
  function should_not_replace_peer_in_allowlist_with_better_score_peer_due_to_max_connections_on_new_session (line 910) | async fn should_not_replace_peer_in_allowlist_with_better_score_peer_due...
  function should_not_replace_peer_not_old_enough_due_to_max_connections_on_new_session (line 968) | async fn should_not_replace_peer_not_old_enough_due_to_max_connections_o...
  function should_remove_session_on_session_closed (line 1020) | async fn should_remove_session_on_session_closed() {
  function should_not_reconnect_to_closed_session_immediately_after_session_closed (line 1051) | async fn should_not_reconnect_to_closed_session_immediately_after_sessio...
  function should_pause_trust_metric_on_session_closed (line 1095) | async fn should_pause_trust_metric_on_session_closed() {
  function should_increase_retry_for_short_alive_session_on_session_closed (line 1111) | async fn should_increase_retry_for_short_alive_session_on_session_closed...
  function should_properly_update_peer_state_even_if_session_not_found_on_session_closed (line 1142) | async fn should_properly_update_peer_state_even_if_session_not_found_on_...
  function should_inc_peer_multiaddr_failure_count_for_io_error_on_connect_failed (line 1163) | async fn should_inc_peer_multiaddr_failure_count_for_io_error_on_connect...
  function should_inc_peer_multiaddr_failure_count_for_dns_error_on_connect_failed (line 1188) | async fn should_inc_peer_multiaddr_failure_count_for_dns_error_on_connec...
  function should_give_up_peer_multiaddr_if_peer_id_not_match_on_connect_failed (line 1215) | async fn should_give_up_peer_multiaddr_if_peer_id_not_match_on_connect_f...
  function should_give_up_peer_itself_if_secio_handshake_error_on_connect_failed (line 1245) | async fn should_give_up_peer_itself_if_secio_handshake_error_on_connect_...
  function should_give_up_peer_itself_if_protocol_handle_error_on_connect_failed (line 1268) | async fn should_give_up_peer_itself_if_protocol_handle_error_on_connect_...
  function should_increase_peer_retry_if_all_multiaddrs_failed_on_conect_failed (line 1289) | async fn should_increase_peer_retry_if_all_multiaddrs_failed_on_conect_f...
  function should_give_up_peer_if_run_out_retry_on_connect_failed (line 1312) | async fn should_give_up_peer_if_run_out_retry_on_connect_failed() {
  function should_return_early_if_we_already_give_up_peer_on_connect_failed (line 1340) | async fn should_return_early_if_we_already_give_up_peer_on_connect_faile...
  function should_wait_for_other_connecting_multiaddrs_if_we_dont_give_up_peer_on_connect_failed (line 1363) | async fn should_wait_for_other_connecting_multiaddrs_if_we_dont_give_up_...
  function should_ensure_disconnect_session_on_session_failed (line 1406) | async fn should_ensure_disconnect_session_on_session_failed() {
  function should_increase_retry_for_io_error_on_session_failed (line 1437) | async fn should_increase_retry_for_io_error_on_session_failed() {
  function should_give_up_peer_for_protocol_error_on_session_failed (line 1455) | async fn should_give_up_peer_for_protocol_error_on_session_failed() {
  function should_give_up_peer_for_unexpected_error_on_session_failed (line 1480) | async fn should_give_up_peer_for_unexpected_error_on_session_failed() {
  function should_reduce_trust_score_on_session_failed (line 1505) | async fn should_reduce_trust_score_on_session_failed() {
  function should_update_peer_alive_on_peer_alive (line 1532) | async fn should_update_peer_alive_on_peer_alive() {
  function should_reset_peer_retry_on_peer_alive (line 1555) | async fn should_reset_peer_retry_on_peer_alive() {
  function should_disconnect_peer_on_misbehave (line 1574) | async fn should_disconnect_peer_on_misbehave() {
  function should_reduce_trust_score_on_misbehave (line 1600) | async fn should_reduce_trust_score_on_misbehave() {
  function should_increase_retry_for_ping_timeout_on_misbehave (line 1626) | async fn should_increase_retry_for_ping_timeout_on_misbehave() {
  function should_give_up_peer_for_ping_unexpect_on_misbehave (line 1643) | async fn should_give_up_peer_for_ping_unexpect_on_misbehave() {
  function should_give_up_peer_for_discovery_on_misbehave (line 1664) | async fn should_give_up_peer_for_discovery_on_misbehave() {
  function should_mark_session_blocked_on_session_blocked (line 1685) | async fn should_mark_session_blocked_on_session_blocked() {
  function should_add_one_bad_event_on_session_blocked (line 1709) | async fn should_add_one_bad_event_on_session_blocked() {
  function should_try_all_peer_multiaddrs_on_connect_peers_now (line 1735) | async fn should_try_all_peer_multiaddrs_on_connect_peers_now() {
  function should_skip_peers_not_in_can_connect_or_not_connected_connectedness_on_connect_peers_now (line 1796) | async fn should_skip_peers_not_in_can_connect_or_not_connected_connected...
  function should_connect_peers_even_if_they_are_not_retry_ready_on_connect_peers_now (line 1824) | async fn should_connect_peers_even_if_they_are_not_retry_ready_on_connec...
  function should_insert_peers_on_discover_multi_addrs (line 1858) | async fn should_insert_peers_on_discover_multi_addrs() {
  function should_not_reset_exist_multiaddr_failure_count_on_discover_multi_addrs (line 1887) | async fn should_not_reset_exist_multiaddr_failure_count_on_discover_mult...
  function should_skip_our_listen_multiaddrs_on_discover_multi_addrs (line 1912) | async fn should_skip_our_listen_multiaddrs_on_discover_multi_addrs() {
  function should_add_multiaddrs_to_peer_on_identified_addrs (line 1934) | async fn should_add_multiaddrs_to_peer_on_identified_addrs() {
  function should_push_id_to_multiaddrs_if_not_included_on_identified_addrs (line 1964) | async fn should_push_id_to_multiaddrs_if_not_included_on_identified_addr...
  function should_not_reset_exist_multiaddr_failure_count_on_identified_addrs (line 1989) | async fn should_not_reset_exist_multiaddr_failure_count_on_identified_ad...
  function should_reset_peer_failure_for_outbound_multiaddr_on_repeated_connection (line 2016) | async fn should_reset_peer_failure_for_outbound_multiaddr_on_repeated_co...
  function should_remove_inbound_multiaddr_on_repeated_connection (line 2044) | async fn should_remove_inbound_multiaddr_on_repeated_connection() {
  function should_enforce_id_if_not_included_on_repeated_connection (line 2066) | async fn should_enforce_id_if_not_included_on_repeated_connection() {
  function should_add_new_listen_on_add_new_listen_addr (line 2094) | async fn should_add_new_listen_on_add_new_listen_addr() {
  function should_push_id_to_listen_multiaddr_if_not_included_on_add_new_listen_addr (line 2119) | async fn should_push_id_to_listen_multiaddr_if_not_included_on_add_new_l...
  function should_remove_listen_on_remove_listen_addr (line 2141) | async fn should_remove_listen_on_remove_listen_addr() {
  function should_remove_listen_even_if_no_peer_id_included_on_remove_listen_addr (line 2163) | async fn should_remove_listen_even_if_no_peer_id_included_on_remove_list...
  function should_always_include_our_listen_addrs_in_return_from_manager_handle_random_addrs (line 2185) | async fn should_always_include_our_listen_addrs_in_return_from_manager_h...
  function should_accept_always_allow_peer_even_if_we_reach_max_connections_on_new_session (line 2208) | async fn should_accept_always_allow_peer_even_if_we_reach_max_connection...
  function should_only_connect_peers_in_allowlist_if_enable_allowlist_only (line 2267) | async fn should_only_connect_peers_in_allowlist_if_enable_allowlist_only...
  function should_only_accept_incoming_from_peer_in_allowlist_if_enable_allowlist_only (line 2333) | async fn should_only_accept_incoming_from_peer_in_allowlist_if_enable_al...
  function should_disconnect_and_ban_peer_for_fatal_feedback_on_trust_metric (line 2423) | async fn should_disconnect_and_ban_peer_for_fatal_feedback_on_trust_metr...
  function should_exclude_always_allow_peer_from_fatal_feedback_ban_on_trust_metric (line 2455) | async fn should_exclude_always_allow_peer_from_fatal_feedback_ban_on_tru...
  function should_add_one_bad_event_for_bad_feedback_on_trust_metric (line 2477) | async fn should_add_one_bad_event_for_bad_feedback_on_trust_metric() {
  function should_add_ten_bad_events_for_worse_feedback_on_trust_metric (line 2497) | async fn should_add_ten_bad_events_for_worse_feedback_on_trust_metric() {
  function should_disconnect_and_soft_ban_peer_if_below_fourty_score_on_worse_feedback_on_trust_metric (line 2517) | async fn should_disconnect_and_soft_ban_peer_if_below_fourty_score_on_wo...
  function should_not_knock_out_peer_just_set_up_trust_metric_on_worse_feedback_on_trust_metric (line 2560) | async fn should_not_knock_out_peer_just_set_up_trust_metric_on_worse_fee...
  function should_not_punish_always_allow_peer_when_its_score_below_fourty_on_worse_feedback_on_trust_metric (line 2592) | async fn should_not_punish_always_allow_peer_when_its_score_below_fourty...
  function should_do_nothing_for_neutral_feedback_on_trust_metric (line 2625) | async fn should_do_nothing_for_neutral_feedback_on_trust_metric() {
  function should_add_one_bad_event_for_good_feedback_on_trust_metric (line 2650) | async fn should_add_one_bad_event_for_good_feedback_on_trust_metric() {
  function should_pick_good_peer_first_on_finding_connectable_peers (line 2670) | async fn should_pick_good_peer_first_on_finding_connectable_peers() {
  function should_setup_trust_metric_if_none_on_session_closed (line 2733) | async fn should_setup_trust_metric_if_none_on_session_closed() {
  function should_setup_trust_metric_if_none_on_session_failed (line 2753) | async fn should_setup_trust_metric_if_none_on_session_failed() {
  function should_setup_trust_metric_if_none_on_peer_misbehave (line 2782) | async fn should_setup_trust_metric_if_none_on_peer_misbehave() {
  function should_setup_trust_metric_if_none_on_session_blocked (line 2810) | async fn should_setup_trust_metric_if_none_on_session_blocked() {
  function should_able_to_tag_peer (line 2843) | async fn should_able_to_tag_peer() {
  function should_able_to_untag_peer (line 2855) | async fn should_able_to_untag_peer() {
  function should_remove_old_consensus_peer_tag_when_tag_consensus (line 2870) | async fn should_remove_old_consensus_peer_tag_when_tag_consensus() {
  function should_reject_same_ip_connection_when_reach_limit_on_new_session (line 2889) | async fn should_reject_same_ip_connection_when_reach_limit_on_new_sessio...
  function should_not_dail_new_peer_after_reach_outbound_conn_limit (line 2963) | async fn should_not_dail_new_peer_after_reach_outbound_conn_limit() {
  function should_reject_inbound_conn_when_reach_inbound_conn_limit (line 2989) | async fn should_reject_inbound_conn_when_reach_inbound_conn_limit() {
  function should_accept_peer_in_allowlist_even_reach_inbound_conn_limit (line 3038) | async fn should_accept_peer_in_allowlist_even_reach_inbound_conn_limit() {
  function should_reject_new_connection_for_same_peer_on_unidentified_session (line 3117) | async fn should_reject_new_connection_for_same_peer_on_unidentified_sess...
  function should_reject_same_ip_connection_when_reach_limit_on_unidentified_session (line 3143) | async fn should_reject_same_ip_connection_when_reach_limit_on_unidentifi...
  function should_accept_always_allow_peer_even_if_we_reach_max_connections_on_unidentified_session (line 3209) | async fn should_accept_always_allow_peer_even_if_we_reach_max_connection...
  function should_remove_connecting_attempt_when_reach_timeout (line 3271) | async fn should_remove_connecting_attempt_when_reach_timeout() {

FILE: core/network/src/peer_manager/time.rs
  function now (line 3) | pub fn now() -> u64 {
  function duration_since (line 7) | pub fn duration_since(now: SystemTime, early: SystemTime) -> Duration {

FILE: core/network/src/peer_manager/trust_metric.rs
  constant PROPORTIONAL_WEIGHT (line 18) | pub const PROPORTIONAL_WEIGHT: f64 = 0.4;
  constant INTERGRAL_WEIGHT (line 19) | pub const INTERGRAL_WEIGHT: f64 = 0.6;
  constant OPTIMISTIC_HISTORY_WEIGHT (line 20) | pub const OPTIMISTIC_HISTORY_WEIGHT: f64 = 0.8;
  constant DERIVATIVE_POSITIVE_WEIGHT (line 21) | pub const DERIVATIVE_POSITIVE_WEIGHT: f64 = 0.0;
  constant DERIVATIVE_NEGATIVE_WEIGHT (line 22) | pub const DERIVATIVE_NEGATIVE_WEIGHT: f64 = 0.1;
  constant INITIAL_HISTORY_VALUE (line 24) | pub const INITIAL_HISTORY_VALUE: f64 = 0.8f64;
  constant KNOCK_OUT_SCORE (line 25) | pub const KNOCK_OUT_SCORE: u8 = 40;
  constant GOOD_INTERVAL_CAP (line 26) | pub const GOOD_INTERVAL_CAP: usize = 30;
  constant DEFAULT_INTERVAL_DURATION (line 28) | pub const DEFAULT_INTERVAL_DURATION: Duration = Duration::from_secs(60);
  constant DEFAULT_MAX_HISTORY_DURATION (line 29) | pub const DEFAULT_MAX_HISTORY_DURATION: Duration = Duration::from_secs(2...
  type TrustMetricConfig (line 39) | pub struct TrustMetricConfig {
    method new (line 47) | pub fn new(interval: Duration, max_history: Duration) -> Self {
    method interval (line 58) | pub fn interval(&self) -> Duration {
    method finish (line 62) | fn finish(mut self) -> Self {
  method default (line 79) | fn default() -> Self {
  type FadedMemory (line 92) | struct FadedMemory(f64);
    method new (line 103) | fn new(history_value: f64) -> Self {
  type Target (line 95) | type Target = f64;
  method deref (line 97) | fn deref(&self) -> &Self::Target {
  type History (line 109) | struct History {
    method new (line 119) | fn new(max_intervals: u64, max_memorys: u64) -> History {
    method intervals (line 131) | fn intervals(&self) -> u64 {
    method latest_trust_value (line 135) | fn latest_trust_value(&self) -> f64 {
    method remember_interval (line 139) | fn remember_interval(&mut self, trust_value: f64) {
    method update_aggregate_trust (line 170) | fn update_aggregate_trust(&mut self) {
  type Inner (line 202) | pub struct Inner {
    method new (line 210) | pub fn new(config: Arc<TrustMetricConfig>) -> Self {
    method trust_score (line 222) | pub fn trust_score(&self) -> u8 {
    method good_events (line 226) | pub fn good_events(&self, num: usize) {
    method bad_events (line 236) | pub fn bad_events(&self, num: usize) {
    method knock_out (line 240) | pub fn knock_out(&self) -> bool {
    method events (line 244) | pub fn events(&self) -> (usize, usize) {
    method enter_new_interval (line 251) | pub fn enter_new_interval(&self) {
    method reset_history (line 265) | pub fn reset_history(&self) {
    method trust_value (line 275) | fn trust_value(&self) -> f64 {
    method proportional_value (line 293) | fn proportional_value(&self) -> Option<f64> {
    method intergral_value (line 304) | fn intergral_value(&self) -> f64 {
  type HeartBeat (line 309) | struct HeartBeat {
    method new (line 318) | pub fn new(
  method drop (line 341) | fn drop(&mut self) {
  type Output (line 348) | type Output = <Delay as Future>::Output;
  method poll (line 350) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...
  type TrustMetric (line 371) | pub struct TrustMetric {
    method new (line 378) | pub fn new(config: Arc<TrustMetricConfig>) -> Self {
    method start (line 386) | pub fn start(&self) {
    method is_started (line 407) | pub fn is_started(&self) -> bool {
    method pause (line 411) | pub fn pause(&self) {
    method bad_events_count (line 418) | pub fn bad_events_count(&self) -> usize {
    method good_events_count (line 423) | pub fn good_events_count(&self) -> usize {
    method intervals (line 428) | pub fn intervals(&self) -> u64 {
  type Target (line 434) | type Target = Arc<Inner>;
  method deref (line 436) | fn deref(&self) -> &Self::Target {
  function basic_metric_test (line 448) | fn basic_metric_test() {
  function good_interval_cap_test (line 502) | fn good_interval_cap_test() {

FILE: core/network/src/protocols/core.rs
  constant PING_PROTOCOL_ID (line 22) | pub const PING_PROTOCOL_ID: usize = 1;
  constant IDENTIFY_PROTOCOL_ID (line 23) | pub const IDENTIFY_PROTOCOL_ID: usize = 2;
  constant DISCOVERY_PROTOCOL_ID (line 24) | pub const DISCOVERY_PROTOCOL_ID: usize = 3;
  constant TRANSMITTER_PROTOCOL_ID (line 25) | pub const TRANSMITTER_PROTOCOL_ID: usize = 4;
  type OpenedProtocols (line 32) | pub struct OpenedProtocols {}
    method register (line 35) | pub fn register(peer_id: PeerId, proto_id: ProtocolId) {
    method unregister (line 46) | pub fn unregister(peer_id: &PeerId, proto_id: ProtocolId) {
    method remove (line 52) | pub fn remove(peer_id: &PeerId) {
    method is_open (line 57) | pub fn is_open(peer_id: &PeerId, proto_id: &ProtocolId) -> bool {
    method is_all_opened (line 65) | pub fn is_all_opened(peer_id: &PeerId) -> bool {
  type CoreProtocolBuilder (line 75) | pub struct CoreProtocolBuilder {
    method new (line 108) | pub fn new() -> Self {
    method ping (line 117) | pub fn ping(
    method identify (line 129) | pub fn identify(
    method discovery (line 140) | pub fn discovery(
    method transmitter (line 152) | pub fn transmitter(
    method build (line 163) | pub fn build(self) -> CoreProtocol {
  type CoreProtocol (line 82) | pub struct CoreProtocol {
    method build (line 88) | pub fn build() -> CoreProtocolBuilder {
    method transmitter (line 92) | pub fn transmitter(&self) -> Transmitter {
  method target (line 98) | fn target() -> TargetProtocol {
  method metas (line 102) | fn metas(self) -> Vec<ProtocolMeta> {

FILE: core/network/src/protocols/discovery.rs
  constant NAME (line 22) | pub const NAME: &str = "chain_discovery";
  constant SUPPORT_VERSIONS (line 23) | pub const SUPPORT_VERSIONS: [&str; 1] = ["0.1"];
  type Discovery (line 25) | pub struct Discovery(DiscoveryProtocol);
    method new (line 28) | pub fn new(
    method build_meta (line 44) | pub fn build_meta(self, protocol_id: ProtocolId) -> ProtocolMeta {

FILE: core/network/src/protocols/discovery/addr.rs
  constant DEFAULT_MAX_KNOWN (line 21) | pub(crate) const DEFAULT_MAX_KNOWN: usize = 5000;
  type Misbehavior (line 23) | pub enum Misbehavior {
  type MisbehaveResult (line 35) | pub enum MisbehaveResult {
    method is_disconnect (line 44) | pub fn is_disconnect(&self) -> bool {
  type AddrReporter (line 49) | struct AddrReporter {
    method new (line 55) | pub fn new(reporter: UnboundedSender<PeerManagerEvent>) -> Self {
    method report (line 63) | pub fn report(&mut self, event: PeerManagerEvent) {
  type AddressManager (line 76) | pub struct AddressManager {
    method new (line 83) | pub fn new(peer_mgr: PeerManagerHandle, event_tx: UnboundedSender<Peer...
    method add_new_addr (line 89) | pub fn add_new_addr(&mut self, _sid: SessionId, addr: Multiaddr) {
    method add_new_addrs (line 95) | pub fn add_new_addrs(&mut self, _sid: SessionId, addrs: Vec<Multiaddr>) {
    method misbehave (line 102) | pub fn misbehave(&mut self, sid: SessionId, _kind: Misbehavior) -> Mis...
    method get_random (line 121) | pub fn get_random(&mut self, n: usize, sid: SessionId) -> Vec<Multiadd...
  type AddrKnown (line 127) | pub struct AddrKnown {
    method new (line 135) | pub(crate) fn new(max_known: usize) -> AddrKnown {
    method insert (line 144) | pub(crate) fn insert(&mut self, key: ConnectableAddr) {
    method contains (line 161) | pub(crate) fn contains(&self, addr: &ConnectableAddr) -> bool {
    method remove (line 165) | pub(crate) fn remove<'a>(&mut self, addrs: impl Iterator<Item = &'a Co...
  method default (line 176) | fn default() -> AddrKnown {
  type ConnectableAddr (line 182) | pub struct ConnectableAddr {
    method from (line 188) | fn from(addr: &Multiaddr) -> ConnectableAddr {
    method from (line 213) | fn from(addr: Multiaddr) -> ConnectableAddr {
    method from (line 219) | fn from(addr: SocketAddr) -> ConnectableAddr {
    method port (line 237) | pub fn port(&self) -> u16 {
    method is_reachable (line 241) | pub fn is_reachable(&self) -> bool {

FILE: core/network/src/protocols/discovery/behaviour.rs
  constant CHECK_INTERVAL (line 22) | const CHECK_INTERVAL: Duration = Duration::from_secs(3);
  type DiscoveryBehaviour (line 24) | pub struct DiscoveryBehaviour {
    method new (line 68) | pub fn new(
    method handle (line 89) | pub fn handle(&self) -> DiscoveryBehaviourHandle {
    method recv_substreams (line 96) | fn recv_substreams(&mut self, cx: &mut Context) {
    method check_interval (line 126) | fn check_interval(&mut self, cx: &mut Context) {
    method poll_substreams (line 144) | fn poll_substreams(&mut self, cx: &mut Context, announce_multiaddrs: &...
    method remove_dead_stream (line 199) | fn remove_dead_stream(&mut self) {
    method send_messages (line 214) | fn send_messages(&mut self, cx: &mut Context) {
  type DiscoveryBehaviourHandle (line 54) | pub struct DiscoveryBehaviourHandle {
    method contains_session (line 60) | pub fn contains_session(&self, session_id: SessionId) -> bool {
  type Item (line 242) | type Item = ();
  method poll_next (line 244) | fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Opt...

FILE: core/network/src/protocols/discovery/message.rs
  type ListenPort (line 7) | pub enum ListenPort {
  type GetNodes (line 13) | pub struct GetNodes {
    method listen_port (line 23) | pub fn listen_port(&self) -> Option<u16> {
  type Node (line 32) | pub struct Node {
    method addrs (line 38) | pub fn addrs(self) -> Vec<Multiaddr> {
    method with_addrs (line 44) | pub fn with_addrs(addrs: Vec<Multiaddr>) -> Self {
  type Nodes (line 52) | pub struct Nodes {
  type Payload (line 60) | pub enum Payload {
  type DiscoveryMessage (line 68) | pub struct DiscoveryMessage {
    method new_get_nodes (line 74) | pub fn new_get_nodes(version: u32, count: u32, listen_port: Option<u16...
    method new_nodes (line 86) | pub fn new_nodes(announce: bool, nodes: Vec<Vec<Multiaddr>>) -> Self {
    method fmt (line 97) | fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Err...
  function discovery_message_serialize_deserialize (line 128) | fn discovery_message_serialize_deserialize() {

FILE: core/network/src/protocols/discovery/protocol.rs
  type DiscoveryProtocol (line 14) | pub struct DiscoveryProtocol {
    method new (line 21) | pub fn new(behaviour: DiscoveryBehaviour) -> DiscoveryProtocol {
  method init (line 32) | fn init(&mut self, context: &mut ProtocolContext) {
  method connected (line 56) | fn connected(&mut self, context: ProtocolContextMutRef, _: &str) {
  method disconnected (line 92) | fn disconnected(&mut self, context: ProtocolContextMutRef) {
  method received (line 100) | fn received(&mut self, context: ProtocolContextMutRef, data: bytes::Byte...

FILE: core/network/src/protocols/discovery/substream.rs
  constant VERSION (line 30) | const VERSION: u32 = 0;
  constant MAX_ADDR_TO_SEND (line 32) | const MAX_ADDR_TO_SEND: u32 = 1000;
  constant ANNOUNCE_INTERVAL (line 34) | const ANNOUNCE_INTERVAL: u64 = 3600 * 24;
  constant ANNOUNCE_THRESHOLD (line 35) | const ANNOUNCE_THRESHOLD: usize = 10;
  constant MAX_ADDRS (line 38) | const MAX_ADDRS: usize = 3;
  type DiscoveryCodec (line 40) | pub(crate) struct DiscoveryCodec {
  method default (line 45) | fn default() -> DiscoveryCodec {
  type Error (line 53) | type Error = io::Error;
  type Item (line 54) | type Item = DiscoveryMessage;
  method decode (line 56) | fn decode(&mut self, src: &mut BytesMut) -> Result<Option<Self::Item>, S...
  type Error (line 75) | type Error = io::Error;
  type Item (line 76) | type Item = DiscoveryMessage;
  method encode (line 78) | fn encode(&mut self, item: Self::Item, dst: &mut BytesMut) -> Result<(),...
  type SubstreamKey (line 90) | pub struct SubstreamKey {
  type StreamHandle (line 96) | pub struct StreamHandle {
  method poll_read (line 105) | fn poll_read(
  method poll_write (line 135) | fn poll_write(self: Pin<&mut Self>, _cx: &mut Context, buf: &[u8]) -> Po...
  method poll_flush (line 146) | fn poll_flush(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<io::Resul...
  method poll_shutdown (line 150) | fn poll_shutdown(self: Pin<&mut Self>, _cx: &mut Context) -> Poll<io::Re...
  type SubstreamValue (line 155) | pub struct SubstreamValue {
    method new (line 173) | pub(crate) fn new(
    method remote_connectable_addr (line 213) | fn remote_connectable_addr(&self) -> ConnectableAddr {
    method check_timer (line 217) | pub(crate) fn check_timer(&mut self) {
    method send_messages (line 228) | pub(crate) fn send_messages(&mut self, cx: &mut Context) -> Result<(),...
    method handle_message (line 248) | pub(crate) fn handle_message(
    method receive_messages (line 376) | pub(crate) fn receive_messages(
  type Substream (line 416) | pub struct Substream {
    method new (line 424) | pub fn new(context: ProtocolContextMutRef, receiver: Receiver<Vec<u8>>...
    method key (line 449) | pub fn key(&self) -> SubstreamKey {
  type RemoteAddress (line 459) | pub(crate) enum RemoteAddress {
    method to_inner (line 467) | fn to_inner(&self) -> &Multiaddr {
    method into_inner (line 473) | pub(crate) fn into_inner(self) -> Multiaddr {
    method update_port (line 479) | fn update_port(&mut self, port: u16) {

FILE: core/network/src/protocols/identify.rs
  constant NAME (line 27) | pub const NAME: &str = "chain_identify";
  constant SUPPORT_VERSIONS (line 28) | pub const SUPPORT_VERSIONS: [&str; 1] = ["0.2"];
  type Identify (line 30) | pub struct Identify {
    method new (line 35) | pub fn new(peer_mgr: PeerManagerHandle, event_tx: UnboundedSender<Peer...
    method build_meta (line 46) | pub fn build_meta(self, protocol_id: ProtocolId) -> ProtocolMeta {
    method build_meta (line 60) | pub fn build_meta(self, protocol_id: ProtocolId) -> ProtocolMeta {
    method wait_identified (line 71) | pub fn wait_identified(peer_id: PeerId) -> WaitIdentification {
    method wait_failed (line 75) | pub fn wait_failed(peer_id: &PeerId, error: String) {

FILE: core/network/src/protocols/identify/behaviour.rs
  type AddrReporter (line 17) | struct AddrReporter {
    method new (line 23) | pub fn new(reporter: UnboundedSender<PeerManagerEvent>) -> Self {
    method report (line 31) | pub fn report(&self, event: PeerManagerEvent) {
  type IdentifyBehaviour (line 45) | pub struct IdentifyBehaviour {
    method new (line 53) | pub fn new(peer_mgr: PeerManagerHandle, event_tx: UnboundedSender<Peer...
    method chain_id (line 62) | pub fn chain_id(&self) -> String {
    method local_listen_addrs (line 66) | pub fn local_listen_addrs(&self) -> Vec<Multiaddr> {
    method send_identity (line 73) | pub fn send_identity(&self, context: &StateContext) {
    method send_ack (line 95) | pub fn send_ack(&self, context: &StateContext) {
    method verify_remote_identity (line 117) | pub fn verify_remote_identity(
    method process_listens (line 128) | pub fn process_listens(&self, context: &StateContext, listens: Vec<Mul...
    method process_observed (line 140) | pub fn process_observed(&self, context: &StateContext, observed: Multi...
    method add_observed_addr (line 156) | pub fn add_observed_addr(

FILE: core/network/src/protocols/identify/common.rs
  function reachable (line 6) | pub fn reachable(addr: &Multiaddr) -> bool {

FILE: core/network/src/protocols/identify/identification.rs
  type Index (line 11) | type Index = usize;
  type WaitIdentification (line 13) | pub struct WaitIdentification {
    method new (line 19) | fn new(ident_status: Arc<Mutex<IdentificationStatus>>) -> Self {
  type Output (line 28) | type Output = Result<(), super::protocol::Error>;
  method poll (line 30) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...
  method drop (line 46) | fn drop(&mut self) {
  type Identification (line 53) | pub struct Identification {
    method new (line 58) | pub(crate) fn new() -> Self {
    method wait (line 64) | pub fn wait(&self) -> WaitIdentification {
    method pass (line 68) | pub fn pass(&self) {
    method failed (line 72) | pub fn failed(&self, error: super::protocol::Error) {
    method fail_if_not_done (line 76) | fn fail_if_not_done(&self) {
    method done (line 87) | fn done(&self, ret: Result<(), super::protocol::Error>) {
  method drop (line 105) | fn drop(&mut self) {
  type IndexedWaker (line 110) | struct IndexedWaker {
    method wake (line 116) | fn wake(self) {
    method borrow (line 122) | fn borrow(&self) -> &Index {
  method eq (line 128) | fn eq(&self, other: &IndexedWaker) -> bool {
  method hash (line 136) | fn hash<H: Hasher>(&self, state: &mut H) {
  type WakerSet (line 141) | struct WakerSet {
    method new (line 147) | fn new() -> WakerSet {
    method insert (line 154) | fn insert(&mut self, waker: Waker) -> Index {
    method remove (line 167) | fn remove(&mut self, idx: Index) {
    method wake (line 171) | fn wake(self) {
  type IdentificationStatus (line 178) | enum IdentificationStatus {
  method default (line 184) | fn default() -> Self {

FILE: core/network/src/protocols/identify/message.rs
  constant MAX_LISTEN_ADDRS (line 8) | pub const MAX_LISTEN_ADDRS: usize = 10;
  type Error (line 11) | pub enum Error {
  type AddressInfoMessage (line 22) | pub trait AddressInfoMessage {
    method validate (line 23) | fn validate(&self) -> Result<(), self::Error>;
    method listen_addrs (line 24) | fn listen_addrs(&self) -> Vec<Multiaddr>;
    method observed_addr (line 25) | fn observed_addr(&self) -> Option<Multiaddr>;
    method listen_addrs (line 29) | fn listen_addrs(&self) -> Vec<Multiaddr> {
    method observed_addr (line 35) | fn observed_addr(&self) -> Option<Multiaddr> {
    method validate (line 39) | fn validate(&self) -> Result<(), self::Error> {
  type AddressInfo (line 48) | pub struct AddressInfo {
    method new (line 56) | pub fn new(listen_addrs: Vec<Multiaddr>, observed_addr: Multiaddr) -> ...
    method listen_addrs (line 63) | pub fn listen_addrs(&self) -> Vec<Multiaddr> {
    method observed_addr (line 69) | pub fn observed_addr(&self) -> Option<Multiaddr> {
    method validate (line 73) | pub fn validate(&self) -> Result<(), self::Error> {
    method mock_valid (line 86) | pub fn mock_valid() -> Self {
    method mock_invalid (line 97) | pub fn mock_invalid() -> Self {
  type Identity (line 106) | pub struct Identity {
    method new (line 114) | pub fn new(chain_id: String, addr_info: AddressInfo) -> Self {
    method validate (line 121) | pub fn validate(&self) -> Result<(), self::Error> {
    method into_bytes (line 125) | pub fn into_bytes(self) -> Result<Bytes, EncodeError> {
    method mock_valid (line 133) | pub fn mock_valid() -> Self {
    method mock_invalid (line 143) | pub fn mock_invalid() -> Self {
  type Acknowledge (line 157) | pub struct Acknowledge {
    method new (line 163) | pub fn new(addr_info: AddressInfo) -> Self {
    method validate (line 169) | pub fn validate(&self) -> Result<(), self::Error> {
    method into_bytes (line 173) | pub fn into_bytes(self) -> Result<Bytes, EncodeError> {
    method mock_valid (line 181) | pub fn mock_valid() -> Self {
    method mock_invalid (line 188) | pub fn mock_invalid() -> Self {

FILE: core/network/src/protocols/identify/protocol.rs
  constant DEFAULT_TIMEOUT (line 33) | pub const DEFAULT_TIMEOUT: Duration = Duration::from_secs(8);
  constant MAX_MESSAGE_SIZE (line 34) | pub const MAX_MESSAGE_SIZE: usize = 5 * 1000;
  type Error (line 43) | pub enum Error {
  type IdentifyProtocolContext (line 74) | pub struct IdentifyProtocolContext<'a>(ProtocolContextMutRef<'a>);
  type IdentifyProtocolContext (line 76) | pub struct IdentifyProtocolContext<'a>(pub &'a crate::test::mock::Protoc...
  type RemotePeer (line 80) | pub struct RemotePeer {
    method from_proto_context (line 89) | pub fn from_proto_context(
  type NoEncryption (line 86) | pub struct NoEncryption;
  type StateContext (line 107) | pub struct StateContext {
    method from_proto_context (line 116) | pub fn from_proto_context(
    method observed_addr (line 131) | pub fn observed_addr(&self) -> Multiaddr {
    method send_message (line 139) | pub fn send_message(&self, msg: Bytes) {
    method disconnect (line 152) | pub fn disconnect(&self) {
    method open_protocols (line 156) | pub fn open_protocols(&self) {
    method set_open_protocols_timeout (line 166) | pub fn set_open_protocols_timeout(&mut self, timeout: Duration) {
    method set_timeout (line 183) | pub fn set_timeout(&mut self, description: &'static str, timeout: Dura...
    method cancel_timeout (line 204) | pub fn cancel_timeout(&self) {
  method drop (line 212) | fn drop(&mut self) {
  type ClientProcedure (line 223) | pub enum ClientProcedure {
  type ServerProcedure (line 235) | pub enum ServerProcedure {
  type State (line 246) | pub enum State {
  type IdentifyProtocol (line 260) | pub struct IdentifyProtocol {
    method new (line 270) | pub fn new(behaviour: Arc<IdentifyBehaviour>) -> Self {
    method new (line 278) | pub fn new() -> Self {
    method wait (line 285) | pub fn wait(peer_id: PeerId) -> WaitIdentification {
    method wait_failed (line 292) | pub fn wait_failed(peer_id: &PeerId, error: String) {
    method on_connected (line 298) | pub fn on_connected(&mut self, protocol_context: &IdentifyProtocolCont...
    method on_disconnected (line 352) | pub fn on_disconnected(&mut self, protocol_context: &IdentifyProtocolC...
    method on_received (line 368) | pub fn on_received(&mut self, protocol_context: &IdentifyProtocolConte...
  method connected (line 512) | fn connected(&mut self, protocol_context: ProtocolContextMutRef, _versio...
  method disconnected (line 516) | fn disconnected(&mut self, protocol_context: ProtocolContextMutRef) {
  method received (line 520) | fn received(&mut self, protocol_context: ProtocolContextMutRef, data: by...
  function finish_identify (line 525) | fn finish_identify(peer: &RemotePeer, result: Result<(), self::Error>) {

FILE: core/network/src/protocols/identify/tests.rs
  constant PROTOCOL_ID (line 16) | const PROTOCOL_ID: usize = 2;
  constant SESSION_ID (line 17) | const SESSION_ID: usize = 2;
  type BehaviourEvent (line 20) | pub enum BehaviourEvent {
  type MockIdentifyBehaviour (line 28) | pub struct MockIdentifyBehaviour {
    method new (line 34) | pub fn new() -> Self {
    method event (line 41) | pub fn event(&self) -> Option<BehaviourEvent> {
    method send_identity (line 45) | pub fn send_identity(&self, _: &StateContext) {
    method send_ack (line 49) | pub fn send_ack(&self, _: &StateContext) {
    method process_listens (line 53) | pub fn process_listens(&self, _: &StateContext, _listen_addrs: Vec<Mul...
    method process_observed (line 57) | pub fn process_observed(&self, _: &StateContext, _observed_addr: Multi...
    method verify_remote_identity (line 61) | pub fn verify_remote_identity(&self, _identity: &message::Identity) ->...
    method skip_chain_id_verify (line 73) | pub fn skip_chain_id_verify(&self, result: bool) {
  function should_reject_unencrypted_connection (line 79) | fn should_reject_unencrypted_connection() {
  function should_wait_client_identity_for_inbound_connection (line 99) | async fn should_wait_client_identity_for_inbound_connection() {
  function should_disconnect_if_wait_client_identity_timeout (line 118) | async fn should_disconnect_if_wait_client_identity_timeout() {
  function should_register_opened_protocol (line 148) | async fn should_register_opened_protocol() {
  function should_send_identity_to_server_for_outbound_connection (line 168) | async fn should_send_identity_to_server_for_outbound_connection() {
  function should_disconnect_if_wait_server_ack_timeout (line 193) | async fn should_disconnect_if_wait_server_ack_timeout() {
  function should_disconnect_if_exceed_max_message_size (line 229) | async fn should_disconnect_if_exceed_max_message_size() {
  function should_send_ack_if_identity_is_valid_on_server_side (line 244) | async fn should_send_ack_if_identity_is_valid_on_server_side() {
  function should_disconnect_if_client_open_protocols_timeout (line 273) | async fn should_disconnect_if_client_open_protocols_timeout() {
  function should_disconnect_if_client_send_undecodeable_identity (line 313) | async fn should_disconnect_if_client_send_undecodeable_identity() {
  function should_disconnect_if_client_send_invalid_identity (line 338) | async fn should_disconnect_if_client_send_invalid_identity() {
  function should_disconnect_if_client_send_different_chain_id (line 363) | async fn should_disconnect_if_client_send_different_chain_id() {
  function should_disconnect_if_client_send_data_during_open_protocols (line 389) | async fn should_disconnect_if_client_send_data_during_open_protocols() {
  function should_open_protocols_after_receive_valid_ack_from_server (line 428) | async fn should_open_protocols_after_receive_valid_ack_from_server() {
  function should_disconnect_if_server_send_undecodeable_ack (line 456) | async fn should_disconnect_if_server_send_undecodeable_ack() {
  function should_disconnect_if_server_send_invalid_ack (line 483) | async fn should_disconnect_if_server_send_invalid_ack() {
  function should_disconnect_if_server_send_data_during_open_protocols (line 508) | async fn should_disconnect_if_server_send_data_during_open_protocols() {
  function should_disconnect_if_either_send_data_no_in_negotiate_procedure (line 546) | async fn should_disconnect_if_either_send_data_no_in_negotiate_procedure...
  function should_wake_wait_identification_after_call_finish_identify (line 563) | async fn should_wake_wait_identification_after_call_finish_identify() {
  function should_pass_error_to_wait_identification_result_if_failed_identify (line 605) | async fn should_pass_error_to_wait_identification_result_if_failed_ident...
  function should_pass_disconnected_to_wait_identification_result_if_still_wait_identify_but_disconnected (line 648) | async fn should_pass_disconnected_to_wait_identification_result_if_still...
  function should_remove_from_opened_protocols_after_disconnect (line 675) | async fn should_remove_from_opened_protocols_after_disconnect() {

FILE: core/network/src/protocols/ping.rs
  constant NAME (line 18) | pub const NAME: &str = "chain_ping";
  constant SUPPORT_VERSIONS (line 19) | pub const SUPPORT_VERSIONS: [&str; 1] = ["0.1"];
  type Ping (line 21) | pub struct Ping(PingProtocol);
    method new (line 24) | pub fn new(
    method build_meta (line 37) | pub fn build_meta(self, protocol_id: ProtocolId) -> ProtocolMeta {

FILE: core/network/src/protocols/ping/behaviour.rs
  type PingEventReporter (line 16) | pub struct PingEventReporter {
    method new (line 22) | pub fn new(inner: UnboundedSender<PeerManagerEvent>) -> Self {
    method is_mgr_shutdown (line 29) | fn is_mgr_shutdown(&self) -> bool {
    method mgr_shutdown (line 33) | fn mgr_shutdown(&self) {
  type EventTranslator (line 41) | pub struct EventTranslator {
  type Output (line 47) | type Output = ();
  method poll (line 49) | fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Ou...

FILE: core/network/src/protocols/ping/message.rs
  type PingPayload (line 5) | pub enum PingPayload {
  type PingMessage (line 13) | pub struct PingMessage {
    method new_pong (line 19) | pub fn new_pong(nonce: u32) -> Self {
    method new_ping (line 25) | pub fn new_ping(nonce: u32) -> Self {
    method into_bytes (line 31) | pub fn into_bytes(self) -> Result<Bytes, EncodeError> {

FILE: core/network/src/protocols/ping/protocol.rs
  constant SEND_PING_TOKEN (line 22) | const SEND_PING_TOKEN: u64 = 0;
  constant CHECK_TIMEOUT_TOKEN (line 23) | const CHECK_TIMEOUT_TOKEN: u64 = 1;
  type PingEvent (line 27) | pub enum PingEvent {
  type PingStatus (line 40) | struct PingStatus {
    method nonce (line 51) | fn nonce(&self) -> u32 {
    method elapsed (line 59) | fn elapsed(&self) -> Duration {
  type PingProtocol (line 71) | pub struct PingProtocol {
    method new (line 79) | pub fn new(
    method send_event (line 92) | pub fn send_event(&mut self, event: PingEvent) {
  method init (line 100) | fn init(&mut self, context: &mut ProtocolContext) {
  method connected (line 117) | fn connected(&mut self, context: ProtocolContextMutRef, version: &str) {
  method disconnected (line 145) | fn disconnected(&mut self, context: ProtocolContextMutRef) {
  method received (line 154) | fn received(&mut self, context: ProtocolContextMutRef, data: bytes::Byte...
  method notify (line 212) | fn notify(&mut self, context: &mut ProtocolContext, token: u64) {

FILE: core/network/src/protocols/transmitter.rs
  constant NAME (line 20) | pub const NAME: &str = "chain_transmitter";
  constant SUPPORT_VERSIONS (line 21) | pub const SUPPORT_VERSIONS: [&str; 1] = ["0.3"];
  constant DATA_SEQ_TIMEOUT (line 22) | pub const DATA_SEQ_TIMEOUT: Duration = Duration::from_secs(60);
  constant MAX_CHUNK_SIZE (line 23) | pub const MAX_CHUNK_SIZE: usize = 4 * 1000 * 1000;
  type Transmitter (line 26) | pub struct Transmitter {
    method new (line 33) | pub fn new(router: MessageRouter<Snappy>, peer_mgr: PeerManagerHandle)...
    method build_meta (line 42) | pub fn build_meta(self, protocol_id: ProtocolId) -> ProtocolMeta {
    method compressor (line 54) | pub fn compressor(&self) -> impl Compression {

FILE: core/network/src/protocols/transmitter/behaviour.rs
  type TransmitterBehaviour (line 31) | pub struct TransmitterBehaviour {
    method new (line 36) | pub fn new() -> Self {
    method init (line 42) | pub fn init(
    method send (line 58) | pub fn send(&self, msg: TransmitterMessage) -> impl Future<Output = Re...
  type PendingSending (line 89) | struct PendingSending {
  type BackgroundSending (line 94) | struct BackgroundSending {
    method new (line 104) | pub fn new(
    method context (line 120) | pub fn context(&self) -> SendingContext<'_> {
  type Output (line 131) | type Output = ();
  method poll (line 133) | fn poll(mut self: Pin<&mut Self>, ctx: &mut Context<'_>) -> Poll<Self::O...
  type MessageContext (line 153) | type MessageContext = protocol::traits::Context;
  type SendingContext (line 155) | struct SendingContext<'a> {
  function send (line 163) | fn send(&self, msg: TransmitterMessage) -> Result<(), NetworkError> {
  function send_to_sessions (line 172) | fn send_to_sessions(
  function send_to_peers (line 296) | fn send_to_peers(
  function filter_blocked (line 331) | fn filter_blocked(

FILE: core/network/src/protocols/transmitter/message.rs
  type Recipient (line 8) | pub enum Recipient {
  type TransmitterMessage (line 13) | pub struct TransmitterMessage {
  type ReceivedMessage (line 20) | pub struct ReceivedMessage {
  type SeqChunkMessage (line 26) | pub(crate) struct SeqChunkMessage {
    method encode (line 33) | pub fn encode(self) -> Bytes {
    method decode (line 45) | pub fn decode(mut bytes: Bytes) -> Self {
  function test_internal_message_codec (line 61) | fn test_internal_message_codec() {

FILE: core/network/src/protocols/transmitter/protocol.rs
  type TransmitterProtocol (line 14) | pub struct TransmitterProtocol {
    method new (line 23) | pub fn new(router: MessageRouter<Snappy>, peer_mgr: PeerManagerHandle)...
  method connected (line 35) | fn connected(&mut self, context: ProtocolContextMutRef, _version: &str) {
  method received (line 52) | fn received(&mut self, ctx: ProtocolContextMutRef, data: Bytes) {

FILE: core/network/src/reactor/mod.rs
  type Reactor (line 19) | pub trait Reactor: Send + Sync {
    method react (line 20) | async fn react(
    method react (line 44) | async fn react(
  type MessageReactor (line 28) | pub struct MessageReactor<M: MessageCodec, H: MessageHandler<Message = M...
  function generate (line 32) | pub fn generate<M: MessageCodec, H: MessageHandler<Message = M>>(h: H) -...
  function rpc_resp (line 36) | pub fn rpc_resp<M: MessageCodec>() -> MessageReactor<M, NoopHandler<M>> {
  type NoopHandler (line 110) | pub struct NoopHandler<M> {
  function new (line 118) | pub fn new() -> Self {
  type Message (line 128) | type Message = M;
  method process (line 130) | async fn process(&self, _: Context, _: Self::Message) -> TrustFeedback {

FILE: core/network/src/reactor/router.rs
  type NoEncryption (line 27) | pub struct NoEncryption {}
  type RemotePeer (line 3

[
  {
    "path": ".dockerignore",
    "chars": 69,
    "preview": "devtools/chain/data\ndevtools/dex\n.github\ndocs\ntests/e2e/node_modules\n"
  },
  {
    "path": ".github/CODEOWNERS",
    "chars": 30,
    "preview": "/ @nervosnetwork/muta-dev-team"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/bug-report.md",
    "chars": 541,
    "preview": "---\nname: Bug Report\nabout: Report a bug\nlabels: t:bug\n---\n\n<!-- Please use this template while reporting a bug and prov"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/feature.md",
    "chars": 238,
    "preview": "---\nname: Feature Request\nabout: Suggest a feature to the Muta-Chain project\nlabels: t:feature\n---\n\n<!-- Please only use"
  },
  {
    "path": ".github/ISSUE_TEMPLATE/help.md",
    "chars": 75,
    "preview": "---\nname: Help me\nabout: What kind of help do you want?\nlabels: t:help\n---\n"
  },
  {
    "path": ".github/PULL_REQUEST_TEMPLATE.md",
    "chars": 432,
    "preview": "<!--  Thanks for sending a pull request! -->\n<!--  Have I run `make ci`? -->\n\n**What this PR does / why we need it**:\n\n\n"
  },
  {
    "path": ".github/semantic.yml",
    "chars": 847,
    "preview": "# By default types specified in commitizen/conventional-commit-types is used.\n# See: https://github.com/commitizen/conve"
  },
  {
    "path": ".gitignore",
    "chars": 480,
    "preview": "# Generated by Cargo\n# will have compiled files and executables\n/target/\n\n# These are backup files generated by rustfmt\n"
  },
  {
    "path": ".helmignore",
    "chars": 398,
    "preview": "# Patterns to ignore when building packages.\n# This supports shell glob matching, relative path matching, and\n# negation"
  },
  {
    "path": "CHANGELOG/CHANGELOG-0.1.md",
    "chars": 55299,
    "preview": "\n\n## [0.1.2-beta](https://github.com/nervosnetwork/muta/compare/v0.1.2-beta2...v0.1.2-beta) (2020-06-04)\n\n\n\n## [0.1.2-be"
  },
  {
    "path": "CHANGELOG/CHANGELOG-0.2.md",
    "chars": 73352,
    "preview": "# [](https://github.com/nervosnetwork/muta/compare/v0.2.0-rc.2.1...v) (2020-09-15)\n\n\n### Bug Fixes\n\n* **cli:** expose ve"
  },
  {
    "path": "CHANGELOG/README.md",
    "chars": 211,
    "preview": "# CHANGELOGs\n> use: conventional-changelog\n>\n> example command: conventional-changelog -p angular -i CHANGELOG-0.2.md -s"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 4691,
    "preview": "# Contributing\n\nOur goal is to make contributing to the `muta` project easy and transparent.\n\nWhen contributing to this "
  },
  {
    "path": "Cargo.toml",
    "chars": 2664,
    "preview": "[package]\nname = \"muta\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository = \"https:"
  },
  {
    "path": "LICENSE",
    "chars": 1074,
    "preview": "MIT License\n\nCopyright (c) 2019 Nervos Foundation\n\nPermission is hereby granted, free of charge, to any person obtaining"
  },
  {
    "path": "Makefile",
    "chars": 2667,
    "preview": "ERBOSE := $(if ${CI},--verbose,)\n\nCOMMIT := $(shell git rev-parse --short HEAD)\n\nifneq (\"$(wildcard /usr/lib/librocksdb."
  },
  {
    "path": "OWNERS",
    "chars": 243,
    "preview": "# See the OWNERS docs at https://go.k8s.io/owners\n\napprovers:\n- yejiayu\n- zeroqn\n- KaoImin \n- LycrusHamster \n- rev-chaos"
  },
  {
    "path": "OWNERS_ALIASES",
    "chars": 251,
    "preview": "aliases:\n- yejiayu\n- zeroqn\n- KaoImin \n- LycrusHamster \n- rev-chaos \n- homura \nbest-approvers:\n- yejiayu\n- zeroqn\n- KaoI"
  },
  {
    "path": "README.md",
    "chars": 4784,
    "preview": "<p align=\"center\">\n  <a href=\"https://github.com/nervosnetwork/muta\">\n    <img src=\"https://github.com/nervosnetwork/mut"
  },
  {
    "path": "README_CN.md",
    "chars": 3117,
    "preview": "<p align=\"center\">\n  <a href=\"https://github.com/nervosnetwork/muta\">\n    <img src=\"https://github.com/nervosnetwork/mut"
  },
  {
    "path": "SECURITY.md",
    "chars": 2350,
    "preview": "# Security Policy\n\nThis project is still under development, the primary goal at this stage is to implement features but "
  },
  {
    "path": "benchmark/bench_executor.rs",
    "chars": 2487,
    "preview": "#![allow(clippy::needless_collect)]\n\nuse asset::types::TransferPayload;\n\nuse super::*;\n\n#[rustfmt::skip]\n/// Bench in In"
  },
  {
    "path": "benchmark/bench_mempool.rs",
    "chars": 1,
    "preview": "\n"
  },
  {
    "path": "benchmark/benchmark_genesis.toml",
    "chars": 1243,
    "preview": "timestamp = 0\nprevhash = \"0x44915be5b6c20b0678cf05fcddbbaa832e25d7e6ac538784cd5c24de00d47472\"\n\n[[services]]\nname = \"asse"
  },
  {
    "path": "benchmark/governance/mod.rs",
    "chars": 6301,
    "preview": "mod types;\n\nuse std::cell::RefCell;\nuse std::convert::From;\nuse std::rc::Rc;\n\nuse bytes::Bytes;\nuse derive_more::{Displa"
  },
  {
    "path": "benchmark/governance/types.rs",
    "chars": 2066,
    "preview": "use std::cmp::Ordering;\n\nuse muta_codec_derive::RlpFixedCodec;\nuse serde::{Deserialize, Serialize};\n\nuse protocol::fixed"
  },
  {
    "path": "benchmark/mod.rs",
    "chars": 8772,
    "preview": "#![allow(clippy::needless_collect)]\n#![feature(test)]\nextern crate test;\n\nuse std::str::FromStr;\nuse std::sync::Arc;\n\nus"
  },
  {
    "path": "binding-macro/Cargo.toml",
    "chars": 625,
    "preview": "[package]\nname = \"binding-macro\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository "
  },
  {
    "path": "binding-macro/src/common.rs",
    "chars": 1703,
    "preview": "use syn::{FnArg, Pat, Path, Type};\n\npub fn get_request_context_pat(bound_name: &str, fn_arg: &FnArg) -> Option<Pat> {\n  "
  },
  {
    "path": "binding-macro/src/cycles.rs",
    "chars": 3248,
    "preview": "use proc_macro::TokenStream;\nuse quote::quote;\nuse syn::parse::{Parse, ParseStream, Result};\nuse syn::punctuated::Punctu"
  },
  {
    "path": "binding-macro/src/hooks.rs",
    "chars": 709,
    "preview": "use proc_macro::TokenStream;\nuse quote::quote;\nuse syn::{parse_macro_input, FnArg, ImplItemMethod};\n\nuse crate::common::"
  },
  {
    "path": "binding-macro/src/lib.rs",
    "chars": 8641,
    "preview": "extern crate proc_macro;\n\nmod common;\nmod cycles;\nmod hooks;\nmod read_write;\nmod service;\n\nuse proc_macro::TokenStream;\n"
  },
  {
    "path": "binding-macro/src/read_write.rs",
    "chars": 1913,
    "preview": "use proc_macro::TokenStream;\nuse quote::quote;\nuse syn::punctuated::Punctuated;\nuse syn::{parse_macro_input, FnArg, Impl"
  },
  {
    "path": "binding-macro/src/service.rs",
    "chars": 17013,
    "preview": "use proc_macro::TokenStream;\nuse quote::quote;\nuse syn::{parse_macro_input, FnArg, Ident, ImplItem, ImplItemMethod, Item"
  },
  {
    "path": "binding-macro/tests/mod.rs",
    "chars": 15556,
    "preview": "#![allow(clippy::unit_cmp)]\n#[macro_use]\nextern crate binding_macro;\n\nuse std::cell::RefCell;\nuse std::panic::{self, Ass"
  },
  {
    "path": "built-in-services/asset/Cargo.toml",
    "chars": 644,
    "preview": "[package]\nname = \"asset\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository = \"https"
  },
  {
    "path": "built-in-services/asset/src/lib.rs",
    "chars": 14092,
    "preview": "#![allow(clippy::mutable_key_type)]\n\n#[cfg(test)]\nmod tests;\npub mod types;\n\nuse std::collections::BTreeMap;\n\nuse bindin"
  },
  {
    "path": "built-in-services/asset/src/tests/mod.rs",
    "chars": 9521,
    "preview": "use std::cell::RefCell;\nuse std::rc::Rc;\nuse std::str::FromStr;\nuse std::sync::Arc;\n\nuse async_trait::async_trait;\nuse c"
  },
  {
    "path": "built-in-services/asset/src/types.rs",
    "chars": 4127,
    "preview": "use std::collections::BTreeMap;\n\nuse muta_codec_derive::RlpFixedCodec;\nuse serde::{Deserialize, Serialize};\n\nuse protoco"
  },
  {
    "path": "built-in-services/authorization/Cargo.toml",
    "chars": 723,
    "preview": "[package]\nname = \"authorization\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository "
  },
  {
    "path": "built-in-services/authorization/src/lib.rs",
    "chars": 1612,
    "preview": "use binding_macro::{cycles, service};\nuse protocol::traits::{ExecutorParams, ServiceResponse, ServiceSDK};\nuse protocol:"
  },
  {
    "path": "built-in-services/metadata/Cargo.toml",
    "chars": 633,
    "preview": "[package]\nname = \"metadata\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository = \"ht"
  },
  {
    "path": "built-in-services/metadata/src/lib.rs",
    "chars": 1176,
    "preview": "#[cfg(test)]\nmod tests;\n\nuse binding_macro::{cycles, genesis, service};\nuse protocol::traits::{ExecutorParams, ServiceRe"
  },
  {
    "path": "built-in-services/metadata/src/tests/mod.rs",
    "chars": 5739,
    "preview": "use std::cell::RefCell;\nuse std::rc::Rc;\nuse std::str::FromStr;\nuse std::sync::Arc;\n\nuse async_trait::async_trait;\nuse c"
  },
  {
    "path": "built-in-services/multi-signature/Cargo.toml",
    "chars": 789,
    "preview": "[package]\nname = \"multi-signature\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepositor"
  },
  {
    "path": "built-in-services/multi-signature/src/lib.rs",
    "chars": 22058,
    "preview": "#![allow(clippy::suspicious_else_formatting, clippy::mutable_key_type)]\n\n#[cfg(test)]\nmod tests;\npub mod types;\n\nuse std"
  },
  {
    "path": "built-in-services/multi-signature/src/tests/curd_test.rs",
    "chars": 13489,
    "preview": "use std::str::FromStr;\n\nuse crate::types::{\n    AddAccountPayload, GenerateMultiSigAccountPayload, GetMultiSigAccountPay"
  },
  {
    "path": "built-in-services/multi-signature/src/tests/mod.rs",
    "chars": 5805,
    "preview": "mod curd_test;\nmod recursion_test;\n\nuse std::cell::RefCell;\nuse std::convert::TryFrom;\nuse std::rc::Rc;\nuse std::sync::A"
  },
  {
    "path": "built-in-services/multi-signature/src/tests/recursion_test.rs",
    "chars": 4860,
    "preview": "use std::str::FromStr;\n\nuse crate::types::{GenerateMultiSigAccountPayload, VerifySignaturePayload};\n\nuse super::*;\n\n#[te"
  },
  {
    "path": "built-in-services/multi-signature/src/types.rs",
    "chars": 6808,
    "preview": "use std::collections::HashMap;\n\nuse muta_codec_derive::RlpFixedCodec;\nuse serde::{Deserialize, Serialize};\n\nuse protocol"
  },
  {
    "path": "built-in-services/util/Cargo.toml",
    "chars": 745,
    "preview": "[package]\nname = \"util\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository = \"https:"
  },
  {
    "path": "built-in-services/util/src/lib.rs",
    "chars": 2366,
    "preview": "use bytes::Bytes;\nuse hasher::{Hasher, HasherKeccak};\n\nuse binding_macro::{cycles, service};\nuse common_crypto::{Crypto,"
  },
  {
    "path": "built-in-services/util/src/tests/mod.rs",
    "chars": 5964,
    "preview": "use std::cell::RefCell;\nuse std::rc::Rc;\nuse std::str::FromStr;\nuse std::sync::Arc;\n\nuse cita_trie::MemoryDB;\nuse rand::"
  },
  {
    "path": "built-in-services/util/src/types.rs",
    "chars": 541,
    "preview": "use protocol::types::{Hash, Hex};\nuse serde::{Deserialize, Serialize};\n\n#[derive(Deserialize, Serialize, Clone, Debug)]\n"
  },
  {
    "path": "byzantine/Cargo.toml",
    "chars": 1289,
    "preview": "[package]\nname = \"byzantine\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository = \"h"
  },
  {
    "path": "byzantine/README.md",
    "chars": 2622,
    "preview": "# 1. 概述\n\n拜占庭测试是通过模拟恶意攻击行为对系统进行安全性和稳定性测试。\n对于区块链这样的分布式系统，节点是通过对外发送/不发送消息来对系统施加影响的。\n因此通过控制消息的发送时间、内容、数量和接收方，我们就可以模拟出任意的恶意行为"
  },
  {
    "path": "byzantine/generators.toml",
    "chars": 8832,
    "preview": "interval = 500\n\n#################\n##### NewTx #####\n#################\n[[list]]\nmsg_type = { NewTxs = \"Valid\" }\nprobabili"
  },
  {
    "path": "byzantine/src/behaviors.rs",
    "chars": 3253,
    "preview": "use bytes::Bytes;\nuse derive_more::Constructor;\nuse serde_derive::Deserialize;\n\nuse core_consensus::message::{\n    Choke"
  },
  {
    "path": "byzantine/src/commander.rs",
    "chars": 3905,
    "preview": "use bytes::Bytes;\nuse futures::{\n    channel::mpsc::{UnboundedReceiver, UnboundedSender},\n    stream::StreamExt,\n};\nuse "
  },
  {
    "path": "byzantine/src/config.rs",
    "chars": 5170,
    "preview": "use std::collections::HashMap;\nuse std::net::SocketAddr;\nuse std::path::PathBuf;\n\nuse serde_derive::Deserialize;\n\nuse co"
  },
  {
    "path": "byzantine/src/default_start.rs",
    "chars": 8193,
    "preview": "use std::collections::HashMap;\nuse std::convert::TryFrom;\nuse std::sync::Arc;\n\nuse bytes::Bytes;\nuse common_crypto::{\n  "
  },
  {
    "path": "byzantine/src/invalid_types.rs",
    "chars": 23817,
    "preview": "use std::error::Error;\nuse std::sync::Arc;\n\nuse bytes::Bytes;\nuse derive_more::Constructor;\nuse overlord::types::SignedP"
  },
  {
    "path": "byzantine/src/lib.rs",
    "chars": 176,
    "preview": "#![allow(clippy::mutable_key_type)]\n\npub mod config;\npub mod default_start;\n\nmod behaviors;\nmod commander;\nmod invalid_t"
  },
  {
    "path": "byzantine/src/message.rs",
    "chars": 3753,
    "preview": "use async_trait::async_trait;\nuse derive_more::Constructor;\nuse futures::channel::mpsc::UnboundedSender;\n\nuse core_conse"
  },
  {
    "path": "byzantine/src/strategy.rs",
    "chars": 2193,
    "preview": "use bytes::Bytes;\nuse derive_more::Constructor;\nuse rand::seq::SliceRandom;\nuse serde_derive::Deserialize;\n\nuse protocol"
  },
  {
    "path": "byzantine/src/utils.rs",
    "chars": 12451,
    "preview": "use std::convert::TryFrom;\nuse std::sync::Arc;\nuse std::time::{SystemTime, UNIX_EPOCH};\n\nuse bytes::Bytes;\nuse overlord:"
  },
  {
    "path": "byzantine/src/worker.rs",
    "chars": 32224,
    "preview": "use std::convert::TryFrom;\nuse std::sync::Arc;\n\nuse bytes::Bytes;\nuse futures::{channel::mpsc::UnboundedReceiver, stream"
  },
  {
    "path": "byzantine/tests/byz.test.ts",
    "chars": 1969,
    "preview": "import { parse } from 'toml';\nimport { find } from 'lodash';\nimport { AssetService, MultiSignatureService } from '@mutad"
  },
  {
    "path": "byzantine/tests/jest.config.js",
    "chars": 216,
    "preview": "module.exports = {\n  displayName: \"Unit Tests\",\n  testRegex: \"(/.*.(test|spec))\\\\.(ts?|js?)$\",\n  transform: {\n    \"^.+\\\\"
  },
  {
    "path": "byzantine/tests/package.json",
    "chars": 669,
    "preview": "{\n  \"name\": \"muta-e2e-tests\",\n  \"version\": \"1.0.0\",\n  \"description\": \"\",\n  \"author\": \"wancencen\",\n  \"license\": \"MIT\",\n  "
  },
  {
    "path": "charts/deploy-chaos/.helmignore",
    "chars": 342,
    "preview": "# Patterns to ignore when building packages.\n# This supports shell glob matching, relative path matching, and\n# negation"
  },
  {
    "path": "charts/deploy-chaos/Chart.yaml",
    "chars": 910,
    "preview": "apiVersion: v2\nname: deploy-chaos\ndescription: A Helm chart for Kubernetes\n\n# A chart can be either an 'application' or "
  },
  {
    "path": "charts/deploy-chaos/templates/_helpers.tpl",
    "chars": 1897,
    "preview": "{{/* vim: set filetype=mustache: */}}\n{{/*\nExpand the name of the chart.\n*/}}\n{{- define \"deploy-chaos.name\" -}}\n{{- def"
  },
  {
    "path": "charts/deploy-chaos/templates/muta-benchmark.yaml",
    "chars": 918,
    "preview": "{{- $chainName  := (printf \"chaos-%s-%s\" .Values.repo_name .Values.version) -}}\napiVersion: batch/v1beta1\nkind: CronJob\n"
  },
  {
    "path": "charts/deploy-chaos/templates/muta-chaos-crd.yaml",
    "chars": 3134,
    "preview": "apiVersion: nervos.org/v1alpha1\nkind: Muta\nmetadata:\n  name: chaos-{{ .Values.repo_name }}-{{ .Values.version }}\n  names"
  },
  {
    "path": "charts/deploy-chaos/values.yaml",
    "chars": 1258,
    "preview": "# Default values for deploy-chaos.\n# This is a YAML-formatted file.\n# Declare variables to be passed into your templates"
  },
  {
    "path": "charts/muta/.helmignore",
    "chars": 333,
    "preview": "# Patterns to ignore when building packages.\n# This supports shell glob matching, relative path matching, and\n# negation"
  },
  {
    "path": "charts/muta/Chart.yaml",
    "chars": 184,
    "preview": "apiVersion: v1\ndescription: A Helm chart for Kubernetes\nicon: https://raw.githubusercontent.com/jenkins-x/jenkins-x-plat"
  },
  {
    "path": "charts/muta/Makefile",
    "chars": 1386,
    "preview": "CHART_REPO := http://jenkins-x-chartmuseum:8080\nCURRENT=$(pwd)\nNAME := muta\nOS := $(shell uname)\nRELEASE_VERSION := $(sh"
  },
  {
    "path": "charts/muta/README.md",
    "chars": 18,
    "preview": "# Rust application"
  },
  {
    "path": "charts/muta/templates/NOTES.txt",
    "chars": 101,
    "preview": "\nGet the application URL by running these commands:\n\nkubectl get ingress {{ template \"fullname\" . }}\n"
  },
  {
    "path": "charts/muta/templates/_helpers.tpl",
    "chars": 516,
    "preview": "{{/* vim: set filetype=mustache: */}}\n{{/*\nExpand the name of the chart.\n*/}}\n{{- define \"name\" -}}\n{{- default .Chart.N"
  },
  {
    "path": "charts/muta/templates/canary.yaml",
    "chars": 2463,
    "preview": "{{- if .Values.canary.enabled }}\napiVersion: flagger.app/v1beta1\nkind: Canary\nmetadata:\n  name: {{ template \"fullname\" ."
  },
  {
    "path": "charts/muta/templates/deployment.yaml",
    "chars": 2048,
    "preview": "{{- if .Values.knativeDeploy }}\n{{- else }}\napiVersion: apps/v1\nkind: Deployment\nmetadata:\n  name: {{ template \"fullname"
  },
  {
    "path": "charts/muta/templates/hpa.yaml",
    "chars": 747,
    "preview": "{{- if .Values.hpa.enabled }}\napiVersion: autoscaling/v2beta1\nkind: HorizontalPodAutoscaler\nmetadata:\n  name: {{ templat"
  },
  {
    "path": "charts/muta/templates/ingress.yaml",
    "chars": 1228,
    "preview": "{{- if and (.Values.jxRequirements.ingress.domain) (not .Values.knativeDeploy) }}\napiVersion: {{ .Values.jxRequirements."
  },
  {
    "path": "charts/muta/templates/ksvc.yaml",
    "chars": 1551,
    "preview": "{{- if .Values.knativeDeploy }}\napiVersion: serving.knative.dev/v1alpha1\nkind: Service\nmetadata:\n{{- if .Values.service."
  },
  {
    "path": "charts/muta/templates/service.yaml",
    "chars": 669,
    "preview": "{{- if or .Values.knativeDeploy .Values.canary.enabled }}\n{{- else }}\napiVersion: v1\nkind: Service\nmetadata:\n{{- if .Val"
  },
  {
    "path": "charts/muta/values.yaml",
    "chars": 2316,
    "preview": "# Default values for Rust projects.\n# This is a YAML-formatted file.\n# Declare variables to be passed into your template"
  },
  {
    "path": "charts/preview/Chart.yaml",
    "chars": 187,
    "preview": "apiVersion: v1\ndescription: A Helm chart for Kubernetes\nicon: https://raw.githubusercontent.com/jenkins-x/jenkins-x-plat"
  },
  {
    "path": "charts/preview/Makefile",
    "chars": 723,
    "preview": "OS := $(shell uname)\n\npreview: \nifeq ($(OS),Darwin)\n\tsed -i \"\" -e \"s/version:.*/version: $(PREVIEW_VERSION)/\" Chart.yaml"
  },
  {
    "path": "charts/preview/requirements.yaml",
    "chars": 433,
    "preview": "# !! File must end with empty line !!\ndependencies:\n- alias: expose\n  name: exposecontroller\n  repository: http://chartm"
  },
  {
    "path": "charts/preview/values.yaml",
    "chars": 408,
    "preview": "cleanup:\n  Annotations:\n    helm.sh/hook: pre-delete\n    helm.sh/hook-delete-policy: hook-succeeded\n  Args:\n  - --cleanu"
  },
  {
    "path": "clippy.toml",
    "chars": 33,
    "preview": "too-many-arguments-threshold = 12"
  },
  {
    "path": "common/apm/Cargo.toml",
    "chars": 462,
    "preview": "[package]\nname = \"common-apm\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository = \""
  },
  {
    "path": "common/apm/README.md",
    "chars": 4824,
    "preview": "# Metrics documentation for promethues\nAll current metrics and usage\n## API\n\n| Metric name | Metric types | Related Graf"
  },
  {
    "path": "common/apm/src/lib.rs",
    "chars": 213,
    "preview": "// https://rust-lang.github.io/rust-clippy/master/index.html#float_cmp\n#![allow(clippy::float_cmp)]\n\npub mod metrics;\n\np"
  },
  {
    "path": "common/apm/src/metrics/api.rs",
    "chars": 2019,
    "preview": "use crate::metrics::{\n    auto_flush_from, exponential_buckets, make_auto_flush_static_metric, register_histogram_vec,\n "
  },
  {
    "path": "common/apm/src/metrics/consensus.rs",
    "chars": 3539,
    "preview": "use crate::metrics::{\n    auto_flush_from, exponential_buckets, make_auto_flush_static_metric, register_histogram,\n    r"
  },
  {
    "path": "common/apm/src/metrics/mempool.rs",
    "chars": 3187,
    "preview": "use crate::metrics::{\n    auto_flush_from, exponential_buckets, make_auto_flush_static_metric, register_histogram_vec,\n "
  },
  {
    "path": "common/apm/src/metrics/network.rs",
    "chars": 6354,
    "preview": "use lazy_static::lazy_static;\n\nuse crate::metrics::{\n    auto_flush_from, exponential_buckets, linear_buckets, make_auto"
  },
  {
    "path": "common/apm/src/metrics/storage.rs",
    "chars": 5080,
    "preview": "use std::time::Duration;\n\nuse lazy_static::lazy_static;\nuse protocol::traits::StorageCategory;\n\nuse crate::metrics::{\n  "
  },
  {
    "path": "common/apm/src/metrics.rs",
    "chars": 1729,
    "preview": "pub mod api;\npub mod consensus;\npub mod mempool;\npub mod network;\npub mod storage;\n\npub use prometheus::{\n    CounterVec"
  },
  {
    "path": "common/channel/Cargo.toml",
    "chars": 277,
    "preview": "[package]\nname = \"common-channel\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository"
  },
  {
    "path": "common/channel/src/lib.rs",
    "chars": 95,
    "preview": "#[cfg(test)]\nmod tests {\n    #[test]\n    fn it_works() {\n        assert_eq!(2 + 2, 4);\n    }\n}\n"
  },
  {
    "path": "common/config-parser/Cargo.toml",
    "chars": 533,
    "preview": "[package]\nname = \"common-config-parser\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepo"
  },
  {
    "path": "common/config-parser/src/lib.rs",
    "chars": 3709,
    "preview": "pub mod types;\n\nuse serde::de;\n\nuse std::error;\nuse std::fmt;\nuse std::fs;\nuse std::io;\nuse std::path::Path;\n\n/// Parse "
  },
  {
    "path": "common/config-parser/src/types.rs",
    "chars": 5543,
    "preview": "use std::collections::HashMap;\nuse std::net::SocketAddr;\nuse std::path::PathBuf;\n\nuse serde_derive::Deserialize;\n\nuse co"
  },
  {
    "path": "common/crypto/Cargo.toml",
    "chars": 481,
    "preview": "[package]\nname = \"common-crypto\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository "
  },
  {
    "path": "common/crypto/src/lib.rs",
    "chars": 13866,
    "preview": "#![feature(test)]\n\npub use ophelia::HashValue;\npub use ophelia::{\n    BlsSignatureVerify, Crypto, Error, PrivateKey, Pub"
  },
  {
    "path": "common/logger/Cargo.toml",
    "chars": 592,
    "preview": "[package]\nname = \"common-logger\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository "
  },
  {
    "path": "common/logger/README.md",
    "chars": 3615,
    "preview": "# Logger Module Instruction\n\n## Logger Config\n\nThe logger config in `config.toml` is listed below with default values.\n\n"
  },
  {
    "path": "common/logger/log.yml",
    "chars": 810,
    "preview": "# This file is yaml style config, can make testing the logger more easily.\n# When you need to do some test, Add the code"
  },
  {
    "path": "common/logger/src/date_fixed_roller.rs",
    "chars": 4235,
    "preview": "use std::error::Error;\nuse std::fs;\nuse std::path::Path;\n\nuse chrono::prelude::Utc;\nuse log4rs::append::rolling_file::po"
  },
  {
    "path": "common/logger/src/lib.rs",
    "chars": 6620,
    "preview": "mod date_fixed_roller;\n\nuse std::collections::HashMap;\nuse std::path::PathBuf;\n\nuse creep::Context;\nuse json::JsonValue;"
  },
  {
    "path": "common/merkle/Cargo.toml",
    "chars": 418,
    "preview": "[package]\nname = \"common-merkle\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository "
  },
  {
    "path": "common/merkle/src/lib.rs",
    "chars": 3224,
    "preview": "#![feature(test)]\n\nuse static_merkle_tree::Tree;\n\nuse protocol::{types::Hash, Bytes};\n\n#[derive(Debug, Clone)]\npub struc"
  },
  {
    "path": "common/pubsub/Cargo.toml",
    "chars": 276,
    "preview": "[package]\nname = \"common-pubsub\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository "
  },
  {
    "path": "common/pubsub/src/lib.rs",
    "chars": 95,
    "preview": "#[cfg(test)]\nmod tests {\n    #[test]\n    fn it_works() {\n        assert_eq!(2 + 2, 4);\n    }\n}\n"
  },
  {
    "path": "core/api/Cargo.toml",
    "chars": 945,
    "preview": "[package]\nname = \"core-api\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository = \"ht"
  },
  {
    "path": "core/api/source/graphiql.html",
    "chars": 19494,
    "preview": "<!DOCTYPE html>\n<html>\n\n<head>\n  <meta charset=utf-8 />\n  <meta name=\"viewport\" content=\"user-scalable=no, initial-scale"
  },
  {
    "path": "core/api/src/adapter/mod.rs",
    "chars": 4667,
    "preview": "use std::marker::PhantomData;\nuse std::sync::Arc;\n\nuse async_trait::async_trait;\nuse derive_more::Display;\n\nuse protocol"
  },
  {
    "path": "core/api/src/config.rs",
    "chars": 1428,
    "preview": "use std::net::SocketAddr;\nuse std::path::PathBuf;\n\n#[derive(Debug, Clone)]\npub struct GraphQLConfig {\n    pub listening_"
  },
  {
    "path": "core/api/src/lib.rs",
    "chars": 15267,
    "preview": "pub mod adapter;\npub mod config;\nmod schema;\n\nuse std::cmp;\nuse std::convert::TryFrom;\nuse std::sync::Arc;\nuse std::time"
  },
  {
    "path": "core/api/src/schema/block.rs",
    "chars": 6209,
    "preview": "use protocol::fixed_codec::FixedCodec;\nuse protocol::types::Hash as PHash;\n\nuse crate::schema::{Address, Bytes, Hash, Me"
  },
  {
    "path": "core/api/src/schema/mod.rs",
    "chars": 3430,
    "preview": "mod block;\nmod receipt;\nmod transaction;\n\nuse std::convert::From;\n\nuse derive_more::{Display, From};\nuse std::num::Parse"
  },
  {
    "path": "core/api/src/schema/receipt.rs",
    "chars": 1708,
    "preview": "use crate::schema::{Hash, MerkleRoot, ServiceResponse, Uint64};\n\n#[derive(juniper::GraphQLObject, Clone)]\npub struct Rec"
  },
  {
    "path": "core/api/src/schema/transaction.rs",
    "chars": 4643,
    "preview": "use protocol::ProtocolResult;\n\nuse crate::schema::{Address, Bytes, Hash, SchemaError, Uint64};\n\n#[derive(juniper::GraphQ"
  },
  {
    "path": "core/cli/Cargo.toml",
    "chars": 1823,
    "preview": "[package]\nname = \"cli\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\n\n# See more keys and "
  },
  {
    "path": "core/cli/src/error.rs",
    "chars": 1031,
    "preview": "use std::error::Error;\n\nuse derive_more::{Display, From};\n\nuse protocol::{ProtocolError, ProtocolErrorKind};\n\n#[derive(D"
  },
  {
    "path": "core/cli/src/lib.rs",
    "chars": 21883,
    "preview": "mod error;\n\n#[cfg(test)]\nmod tests;\n\nuse std::fs;\nuse std::ops::RangeInclusive;\nuse std::path::{Path, PathBuf};\nuse std:"
  },
  {
    "path": "core/cli/src/tests/config.toml",
    "chars": 1264,
    "preview": "# crypto\nprivkey = \"0x5ec982173d54d830b6789cbbbe43eaa2853a5ff752d1ebc1b266cf9790314f8a\"\n\n# db config\ndata_path = \"./free"
  },
  {
    "path": "core/cli/src/tests/genesis.toml",
    "chars": 1315,
    "preview": "timestamp = 0\nprevhash = \"0x44915be5b6c20b0678cf05fcddbbaa832e25d7e6ac538784cd5c24de00d47472\"\n\n[[services]]\nname = \"asse"
  },
  {
    "path": "core/cli/src/tests/mod.rs",
    "chars": 12554,
    "preview": "mod service_mapping;\n\nuse std::path::PathBuf;\nuse std::str::FromStr;\n\nuse protocol::traits::{CommonStorage, Context};\nus"
  },
  {
    "path": "core/cli/src/tests/service_mapping.rs",
    "chars": 2446,
    "preview": "// This file is copied directly from example/muta-chain\n\nuse derive_more::{Display, From};\nuse protocol::traits::{SDKFac"
  },
  {
    "path": "core/consensus/Cargo.toml",
    "chars": 1307,
    "preview": "[package]\nname = \"core-consensus\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository"
  },
  {
    "path": "core/consensus/src/adapter.rs",
    "chars": 33525,
    "preview": "use std::boxed::Box;\nuse std::collections::HashMap;\nuse std::marker::PhantomData;\nuse std::sync::Arc;\nuse std::time::Ins"
  },
  {
    "path": "core/consensus/src/consensus.rs",
    "chars": 7694,
    "preview": "use std::sync::Arc;\n\nuse async_trait::async_trait;\nuse creep::Context;\nuse futures::lock::Mutex;\nuse overlord::types::{\n"
  },
  {
    "path": "core/consensus/src/engine.rs",
    "chars": 30849,
    "preview": "use std::collections::{HashMap, HashSet};\nuse std::convert::TryFrom;\nuse std::error::Error;\nuse std::sync::Arc;\nuse std:"
  },
  {
    "path": "core/consensus/src/fixed_types.rs",
    "chars": 7926,
    "preview": "use std::error::Error;\n\nuse overlord::Codec;\n\nuse protocol::codec::{Deserialize, ProtocolCodecSync, Serialize};\nuse prot"
  },
  {
    "path": "core/consensus/src/lib.rs",
    "chars": 5822,
    "preview": "#![feature(test)]\n#![allow(\n    clippy::type_complexity,\n    clippy::suspicious_else_formatting,\n    clippy::mutable_key"
  },
  {
    "path": "core/consensus/src/message.rs",
    "chars": 10546,
    "preview": "use std::sync::Arc;\n\nuse async_trait::async_trait;\nuse bincode::serialize;\nuse futures::TryFutureExt;\nuse log::warn;\nuse"
  },
  {
    "path": "core/consensus/src/status.rs",
    "chars": 8854,
    "preview": "use std::sync::Arc;\n\nuse derive_more::Display;\nuse parking_lot::RwLock;\nuse serde::{Deserialize, Serialize};\n\nuse common"
  },
  {
    "path": "core/consensus/src/synchronization.rs",
    "chars": 16891,
    "preview": "use std::sync::Arc;\nuse std::time::{Duration, Instant};\n\nuse async_trait::async_trait;\nuse futures::lock::Mutex;\nuse fut"
  },
  {
    "path": "core/consensus/src/tests/engine.rs",
    "chars": 8340,
    "preview": "use std::collections::HashMap;\nuse std::convert::TryFrom;\nuse std::sync::Arc;\n\nuse async_trait::async_trait;\nuse futures"
  },
  {
    "path": "core/consensus/src/tests/mod.rs",
    "chars": 3910,
    "preview": "mod engine;\nmod status;\nmod synchronization;\n\nuse rand::random;\n\nuse protocol::types::{Address, Block, BlockHeader, Hash"
  },
  {
    "path": "core/consensus/src/tests/status.rs",
    "chars": 4814,
    "preview": "use creep::Context;\nuse rand::random;\n\nuse protocol::fixed_codec::FixedCodec;\nuse protocol::types::{Hash, Hex, Metadata,"
  },
  {
    "path": "core/consensus/src/tests/synchronization.rs",
    "chars": 42001,
    "preview": "use std::collections::{HashMap, HashSet};\nuse std::convert::TryFrom;\nuse std::str::FromStr;\nuse std::sync::Arc;\n\nuse asy"
  },
  {
    "path": "core/consensus/src/util.rs",
    "chars": 11398,
    "preview": "use std::collections::HashMap;\nuse std::convert::TryFrom;\nuse std::error::Error;\nuse std::time::{SystemTime, UNIX_EPOCH}"
  },
  {
    "path": "core/consensus/src/wal.rs",
    "chars": 18347,
    "preview": "use std::fs;\nuse std::io::{ErrorKind, Read, Write};\nuse std::path::{Path, PathBuf};\n\nuse common_apm::muta_apm;\nuse proto"
  },
  {
    "path": "core/consensus/src/wal_proto.rs",
    "chars": 1814,
    "preview": "use std::convert::TryFrom;\n\nuse prost::Message;\n\nuse protocol::codec::{transaction, ProtocolCodecSync};\nuse protocol::ty"
  },
  {
    "path": "core/mempool/Cargo.toml",
    "chars": 929,
    "preview": "[package]\nname = \"core-mempool\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository ="
  },
  {
    "path": "core/mempool/src/adapter/message.rs",
    "chars": 4013,
    "preview": "use std::sync::Arc;\nuse std::time::Instant;\n\nuse async_trait::async_trait;\nuse futures::future::{try_join_all, TryFuture"
  },
  {
    "path": "core/mempool/src/adapter/mod.rs",
    "chars": 21211,
    "preview": "use super::TxContext;\n\npub mod message;\n\nuse std::{\n    error::Error,\n    marker::PhantomData,\n    sync::atomic::{Atomic"
  },
  {
    "path": "core/mempool/src/context.rs",
    "chars": 511,
    "preview": "use protocol::traits::Context;\n\nconst TXS_ORIGINAL_KEY: &str = \"txs_original\";\nconst NETWORK_TXS: usize = 1;\n\npub(crate)"
  },
  {
    "path": "core/mempool/src/lib.rs",
    "chars": 14733,
    "preview": "#![feature(async_closure, test)]\n#![allow(clippy::suspicious_else_formatting, clippy::mutable_key_type)]\n\nmod adapter;\nm"
  },
  {
    "path": "core/mempool/src/map.rs",
    "chars": 5770,
    "preview": "use std::collections::HashMap;\nuse std::sync::Arc;\n\nuse futures::future::try_join_all;\nuse tokio::sync::RwLock;\n\nuse pro"
  },
  {
    "path": "core/mempool/src/tests/mempool.rs",
    "chars": 16794,
    "preview": "use std::sync::Arc;\n\nuse test::Bencher;\n\nuse protocol::types::Hash;\n\nuse super::*;\n\nmacro_rules! insert {\n    (normal($p"
  },
  {
    "path": "core/mempool/src/tests/mod.rs",
    "chars": 8507,
    "preview": "extern crate test;\n\nmod mempool;\n\nuse std::convert::{From, TryFrom};\nuse std::sync::Arc;\n\nuse async_trait::async_trait;\n"
  },
  {
    "path": "core/mempool/src/tx_cache.rs",
    "chars": 21787,
    "preview": "use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};\nuse std::sync::Arc;\n\nuse crossbeam_queue::ArrayQueue;\n\nuse p"
  },
  {
    "path": "core/network/Cargo.toml",
    "chars": 1229,
    "preview": "[package]\nname = \"core-network\"\nversion = \"0.2.1\"\nauthors = [\"Muta Dev <muta@nervos.org>\"]\nedition = \"2018\"\nrepository ="
  },
  {
    "path": "core/network/examples/buycopy.rs",
    "chars": 4869,
    "preview": "use std::{\n    net::{IpAddr, Ipv4Addr, SocketAddr},\n    thread,\n    time::Duration,\n};\n\nuse async_trait::async_trait;\nus"
  },
  {
    "path": "core/network/src/common.rs",
    "chars": 5237,
    "preview": "use crate::traits::MultiaddrExt;\n\nuse derive_more::Display;\nuse futures::{pin_mut, task::AtomicWaker};\nuse futures_timer"
  },
  {
    "path": "core/network/src/compression/mod.rs",
    "chars": 36,
    "preview": "mod snappy;\npub use snappy::Snappy;\n"
  },
  {
    "path": "core/network/src/compression/snappy.rs",
    "chars": 954,
    "preview": "use std::io;\n\nuse protocol::Bytes;\n\nuse crate::{error::NetworkError, traits::Compression};\n\n#[derive(Clone)]\npub struct "
  },
  {
    "path": "core/network/src/config.rs",
    "chars": 15378,
    "preview": "use std::{\n    default::Default,\n    net::{IpAddr, Ipv4Addr, SocketAddr},\n    path::{Path, PathBuf},\n    str::FromStr,\n "
  },
  {
    "path": "core/network/src/connection/control.rs",
    "chars": 1000,
    "preview": "use tentacle::error::SendErrorKind;\nuse tentacle::service::{ServiceControl, TargetSession};\nuse tentacle::ProtocolId;\n\nu"
  },
  {
    "path": "core/network/src/connection/keeper.rs",
    "chars": 9349,
    "preview": "use std::sync::atomic::{AtomicBool, Ordering};\n\nuse futures::channel::mpsc::UnboundedSender;\nuse log::{debug, error};\nus"
  },
  {
    "path": "core/network/src/connection/mod.rs",
    "chars": 6565,
    "preview": "mod control;\nmod keeper;\n\npub use control::{ConnectionServiceControl, ProtocolMessage};\npub use keeper::ConnectionServic"
  },
  {
    "path": "core/network/src/endpoint.rs",
    "chars": 5137,
    "preview": "use std::{\n    cmp::PartialEq,\n    convert::TryFrom,\n    hash::{Hash, Hasher},\n    str::FromStr,\n};\n\nuse derive_more::{D"
  },
  {
    "path": "core/network/src/error.rs",
    "chars": 5625,
    "preview": "use std::{error::Error, num::ParseIntError};\n\nuse derive_more::Display;\nuse tentacle::{\n    multiaddr::Multiaddr,\n    se"
  },
  {
    "path": "core/network/src/event.rs",
    "chars": 5286,
    "preview": "use std::{error::Error, sync::Arc};\n\nuse derive_more::Display;\nuse protocol::traits::TrustFeedback;\n#[cfg(not(test))]\nus"
  },
  {
    "path": "core/network/src/lib.rs",
    "chars": 1494,
    "preview": "mod common;\nmod compression;\nmod config;\nmod connection;\nmod endpoint;\nmod error;\nmod event;\nmod message;\nmod metrics;\nm"
  },
  {
    "path": "core/network/src/message/mod.rs",
    "chars": 3601,
    "preview": "pub mod serde;\npub mod serde_multi;\n\nuse std::{collections::HashMap, str::FromStr};\n\nuse common_apm::muta_apm::rustracin"
  },
  {
    "path": "core/network/src/message/serde.rs",
    "chars": 995,
    "preview": "use std::fmt;\n\nuse protocol::codec::ProtocolCodecSync;\nuse protocol::Bytes;\nuse serde::{de, ser, Deserializer, Serialize"
  },
  {
    "path": "core/network/src/message/serde_multi.rs",
    "chars": 2896,
    "preview": "use std::{fmt, iter::FromIterator, marker::PhantomData};\n\nuse derive_more::Constructor;\nuse protocol::codec::ProtocolCod"
  },
  {
    "path": "core/network/src/metrics.rs",
    "chars": 2025,
    "preview": "use std::{\n    future::Future,\n    pin::Pin,\n    sync::Arc,\n    task::{Context, Poll},\n    time::Duration,\n};\n\nuse futur"
  },
  {
    "path": "core/network/src/outbound/gossip.rs",
    "chars": 3725,
    "preview": "use async_trait::async_trait;\nuse protocol::traits::{Context, Gossip, MessageCodec, Priority};\nuse protocol::{Bytes, Pro"
  },
  {
    "path": "core/network/src/outbound/mod.rs",
    "chars": 77,
    "preview": "mod gossip;\nmod rpc;\npub use gossip::NetworkGossip;\npub use rpc::NetworkRpc;\n"
  },
  {
    "path": "core/network/src/outbound/rpc.rs",
    "chars": 5755,
    "preview": "use std::time::Instant;\n\nuse async_trait::async_trait;\nuse futures::future::{self, Either};\nuse futures_timer::Delay;\nus"
  },
  {
    "path": "core/network/src/peer_manager/addr_set.rs",
    "chars": 4986,
    "preview": "use super::{PeerMultiaddr, MAX_RETRY_COUNT};\n\nuse std::{\n    borrow::{Borrow, Cow},\n    collections::HashSet,\n    hash::"
  },
  {
    "path": "core/network/src/peer_manager/diagnostic.rs",
    "chars": 2713,
    "preview": "use super::{Inner, WORSE_TRUST_SCALAR_RATIO};\nuse crate::event::PeerManagerEvent;\n\nuse derive_more::Display;\nuse protoco"
  },
  {
    "path": "core/network/src/peer_manager/mod.rs",
    "chars": 54250,
    "preview": "#![allow(clippy::mutable_key_type)]\n\nmod addr_set;\nmod peer;\nmod retry;\nmod save_restore;\nmod session_book;\nmod shared;\n"
  },
  {
    "path": "core/network/src/peer_manager/peer.rs",
    "chars": 9378,
    "preview": "use super::{time, PeerAddrSet, Retry, Tags, TrustMetric, MAX_RETRY_COUNT};\n\nuse std::{\n    borrow::Borrow,\n    fmt,\n    "
  },
  {
    "path": "core/network/src/peer_manager/retry.rs",
    "chars": 1835,
    "preview": "use super::{time, BACKOFF_BASE, MAX_RETRY_INTERVAL};\n\nuse std::sync::{\n    atomic::{AtomicU64, AtomicU8, Ordering},\n    "
  },
  {
    "path": "core/network/src/peer_manager/save_restore.rs",
    "chars": 7519,
    "preview": "use super::{ArcPeer, Connectedness, PeerMultiaddr};\n\nuse std::{\n    convert::TryFrom,\n    fmt,\n    fs::File,\n    io::{Bu"
  },
  {
    "path": "core/network/src/peer_manager/session_book.rs",
    "chars": 11664,
    "preview": "use std::borrow::Borrow;\nuse std::collections::{HashMap, HashSet};\nuse std::hash::{Hash, Hasher};\nuse std::ops::Deref;\nu"
  },
  {
    "path": "core/network/src/peer_manager/shared.rs",
    "chars": 4549,
    "preview": "use std::sync::Arc;\n\nuse log::debug;\nuse protocol::traits::PeerTag;\nuse tentacle::secio::PeerId;\nuse tentacle::SessionId"
  },
  {
    "path": "core/network/src/peer_manager/tags.rs",
    "chars": 1776,
    "preview": "use super::time;\nuse crate::error::NetworkError;\n\nuse derive_more::Display;\nuse parking_lot::RwLock;\nuse protocol::trait"
  },
  {
    "path": "core/network/src/peer_manager/test_manager.rs",
    "chars": 109323,
    "preview": "#![allow(clippy::needless_collect)]\n\nuse super::{\n    time, ArcPeer, Connectedness, ConnectingAttempt, Inner, Misbehavio"
  },
  {
    "path": "core/network/src/peer_manager/time.rs",
    "chars": 321,
    "preview": "use std::time::{Duration, SystemTime, UNIX_EPOCH};\n\npub fn now() -> u64 {\n    duration_since(SystemTime::now(), UNIX_EPO"
  },
  {
    "path": "core/network/src/peer_manager/trust_metric.rs",
    "chars": 14527,
    "preview": "use futures::{\n    future::{self, AbortHandle},\n    pin_mut,\n};\nuse futures_timer::Delay;\nuse parking_lot::RwLock;\n\nuse "
  },
  {
    "path": "core/network/src/protocols/core.rs",
    "chars": 5210,
    "preview": "use std::collections::{HashMap, HashSet};\nuse std::iter::FromIterator;\nuse std::time::Duration;\n\nuse futures::channel::m"
  },
  {
    "path": "core/network/src/protocols/discovery/addr.rs",
    "chars": 6828,
    "preview": "use crate::{\n    event::{MisbehaviorKind, PeerManagerEvent},\n    peer_manager::PeerManagerHandle,\n};\n\nuse futures::chann"
  },
  {
    "path": "core/network/src/protocols/discovery/behaviour.rs",
    "chars": 10072,
    "preview": "use std::collections::{HashMap, HashSet, VecDeque};\nuse std::pin::Pin;\nuse std::task::{Context, Poll};\nuse std::time::{D"
  },
  {
    "path": "core/network/src/protocols/discovery/message.rs",
    "chars": 3706,
    "preview": "use std::convert::TryFrom;\n\nuse prost::{Message, Oneof};\nuse tentacle::multiaddr::Multiaddr;\n\n#[derive(Clone, Copy, Part"
  },
  {
    "path": "core/network/src/protocols/discovery/protocol.rs",
    "chars": 3991,
    "preview": "use std::collections::HashMap;\n\nuse futures::channel::mpsc::{channel, Sender};\nuse futures::stream::StreamExt;\nuse futur"
  },
  {
    "path": "core/network/src/protocols/discovery/substream.rs",
    "chars": 17062,
    "preview": "use super::{\n    addr::{AddrKnown, AddressManager, ConnectableAddr, Misbehavior},\n    message::{DiscoveryMessage, Nodes,"
  },
  {
    "path": "core/network/src/protocols/discovery.rs",
    "chars": 1481,
    "preview": "mod addr;\nmod behaviour;\nmod message;\nmod protocol;\nmod substream;\n\nuse self::protocol::DiscoveryProtocol;\nuse addr::Add"
  },
  {
    "path": "core/network/src/protocols/identify/behaviour.rs",
    "chars": 4990,
    "preview": "use std::sync::atomic::{AtomicBool, Ordering};\nuse std::sync::Arc;\n\nuse futures::channel::mpsc::UnboundedSender;\nuse ten"
  }
]

// ... and 148 more files (download for full content)