Crate ave 

Ave

Open-source Rust workspace for building, embedding, and exposing Ave ledger nodes.

Ave is organized as a set of crates that cover the full stack of a node:

• cryptographic identity primitives
• shared domain and API types
• peer-to-peer networking
• runtime orchestration and contract execution
• application integration
• a ready-to-run HTTP API server

This repository is intended both for users who want to run Ave components and for developers who want to inspect, extend, or reuse parts of the stack.

What this repository contains

The workspace is split into focused crates:

Crate	Purpose
ave-identity	Cryptographic primitives, keys, signatures, hashes
ave-common	Shared domain models, bridge types, and common utilities
ave-network	libp2p-based peer-to-peer networking layer
ave-core	Main runtime engine for building and running Ave nodes
ave-bridge	Application-facing integration layer over the runtime
ave-http	Axum-based HTTP API, auth system, admin surface, and startup wiring

The runtime also depends on the sibling ave-actors workspace for the actor model and persistence backends.

How the pieces fit together

At a high level:

1. ave-identity provides keys, signatures, and digest types.
2. ave-common defines the shared request, response, governance, and bridge-facing models.
3. ave-network provides peer discovery, messaging, and node networking.
4. ave-core combines networking, persistence, contract execution, and workflow logic into a node runtime.
5. ave-bridge wraps the runtime into a simpler integration surface for services and applications.
6. ave-http exposes that integration layer over HTTP with authentication, admin APIs, OpenAPI, and operational middleware.

If you only need one layer, you can depend on that crate directly. If you want the full HTTP server, start with ave-http.

Main capabilities

• event-driven node runtime built in Rust
• actor-based orchestration
• peer-to-peer networking over libp2p
• internal persistence with SQLite or RocksDB
• external SQLite-backed ledger/state storage
• Wasmtime-based contract execution
• sink delivery to external systems with retries and auth bootstrap
• HTTP API with auth, admin endpoints, quotas, API keys, and audit logs
• OpenAPI generation and Swagger UI
• Prometheus metrics support

Repository layout

Top-level folders you will likely care about first:

• identity: crypto crate
• common: shared models
• network: P2P layer
• core: runtime engine
• bridge: application integration layer
• http: HTTP server and Docker build flow

If you are browsing the code for the first time, a good reading order is:

1. core/README.md
2. network/README.md
3. bridge/README.md
4. http/README.md

Getting started

Requirements

• Rust toolchain compatible with the workspace rust-version
• Cargo
• Docker, if you want to build the container images from http/docker

Build the workspace

cargo build --workspace

Run the workspace tests

cargo test --workspace

Check formatting and lints

cargo fmt --all --check
cargo clippy --workspace --all-targets --all-features

Running the HTTP server

The ready-to-run executable is in the ave-http crate.

Run it with the default feature set:

cargo run -p ave-http

Feature constraints used across the runtime:

• exactly one of sqlite or rocksdb must be enabled
• ext-sqlite is required by the current runtime

Example with RocksDB internal storage:

cargo run -p ave-http --no-default-features --features "rocksdb ext-sqlite prometheus"

Docker builds

The repository includes Docker build assets under http/docker.

The main build helper is:

• http/docker/build.sh

That script supports:

• production builds for both AMD64 and ARM64
• development builds for selected architectures
• SQLite and RocksDB variants
• separate Cargo profiles for production and experimental builds

Configuration

Configuration is layered through the workspace:

• ave-core defines the runtime configuration
• ave-bridge adds application, auth, logging, sink, and HTTP-related settings
• ave-http uses that configuration to start the full HTTP service

The most important configuration areas are:

• key management
• network addresses and boot nodes
• internal and external database paths
• logging outputs and rotation
• sink destinations and sink auth
• HTTP, TLS, proxy, and CORS behavior
• auth and rate-limit settings

Which crate should I use?

• Use ave-http if you want a complete HTTP server.
• Use ave-bridge if you want to embed Ave into an application or daemon.
• Use ave-core if you want the runtime engine directly.
• Use ave-network if you only need the P2P layer.
• Use ave-common for shared domain and API models.
• Use ave-identity for cryptographic primitives.

For developers reading the code

If you are here to understand the internals rather than just use the crates:

• start in core/src/lib.rs to see the runtime entry points
• inspect network/src/lib.rs and network/src/worker.rs for the networking layer
• inspect bridge/src/lib.rs for the integration facade
• inspect http/src/startup.rs and http/src/server.rs for process startup and HTTP routes

That path gives a reasonable top-down view of how the workspace is assembled.

Open source

Ave is free software. The source is published so it can be studied, audited, adapted, and improved by others.

This project is a fork of kore, originally developed by Kore Ledger, SL, modified in 2025 by Averiun Ledger, SL, and distributed under the same AGPL-3.0-only license.

Re-exports

pub use ave_bridge as bridge;

pub use ave_common as common;

pub use ave_core as core;

pub use ave_identity as identity;

pub use ave_network as network;

Structs

Api

AveApi

AveConfig

Node configuration.

Bridge

BridgeConfig

ControlListConfig

Configuration for the control list behaviour.

DigestIdentifier

Digest bytes plus the algorithm used to produce them.

Namespace

Dot-separated namespace.

NetworkConfig

Network config

NetworkWorker

Main network worker. Must be polled in order for the network to advance.

PublicKey

Public key bytes plus the algorithm used to interpret them.

RoutingConfig

Configuration for the routing behaviour.

RoutingNode

A node in the routing table.

Enums

BridgeError

Bridge API errors.

CoreError

Core API errors that may be returned to users.

KeyPair

Owns a signing key and exposes a stable high-level API.

KeyPairAlgorithm

Key pair algorithms supported by this crate.

MachineProfile

Predefined instance profiles with fixed vCPU and RAM. They only exist to provide convenient default values — the actual network tuning is derived from the resolved ram_mb and cpu_cores.

MachineSpec

How to size the network backend.

NodeType

Type of a node.