Feedable Network
FEEDABLE NETWORK
Feedable Network
FEEDABLE NETWORK
Feedable Network
FEEDABLE NETWORK
Back to blog
·11 min read

Building on Feedable Network: A Developer Guide

This guide is for developers who want to run a node, submit inference jobs, or build on top of Feedable Network. It covers the current devnet setup, the gRPC API, the key management requirements, and the path toward testnet.

Prerequisites

Validator node (light — no Blazil required):

  • 4 vCPU, 16GB RAM, any VPS provider
  • Ubuntu 24.04 LTS recommended
  • Rust stable toolchain (1.78+)
  • Open ports: 30333 (P2P), 9090 (gRPC), 9100 (Prometheus)

Miner node (heavy — requires Blazil):

  • 16+ vCPU, 128GB RAM, NVMe storage
  • AWS i4i.4xlarge class or equivalent
  • Blazil installed and configured (see Blazil docs)
  • /dev/shm/aeron available for IPC

Building from source

git clone https://github.com/feedable-network-lab/feedable-blockchain-coin
cd feedable-blockchain-coin
cargo build --release

The build takes 3-5 minutes on first run. All dependencies are pinned in Cargo.lock. The release binary is at target/release/fc-node.

To verify the build:

cargo test --workspace
cargo clippy --workspace -- -D warnings

Both must pass before running a node.

Key generation

Each node requires an Ed25519 keypair. The private key signs FeedReceipts (miner) and BFT votes (validator). Keep it secure — loss means loss of staked funds.

./fc-node keygen --output /var/lib/feedable/validator.key
./fc-node keygen --show-pubkey /var/lib/feedable/validator.key

The public key is your node identity and account address on-chain. Fund it with F before staking.

Minimum stake requirements:

  • Miner node: 1,000 F
  • Validator node: 100 F

Configuration

Create /etc/feedable/feedable.toml:

[node]
mode      = "validator"   # or "miner"
data_dir  = "/var/lib/feedable"
log_level = "info"

[network]
listen_addr     = "/ip4/0.0.0.0/tcp/30333"
bootstrap_peers = [
  "/ip4/seed1.feedable.network/tcp/30333/p2p/12D3...",
  "/ip4/seed2.feedable.network/tcp/30333/p2p/12D3...",
]

[consensus]
validator_key = "/var/lib/feedable/validator.key"
stake_amount  = 100_000000   # 100 F in minor units (1 F = 1,000,000)

[rpc]
grpc_addr    = "0.0.0.0:9090"
data_api_addr = "0.0.0.0:8080"

[metrics]
prometheus_addr = "0.0.0.0:9100"

For miner nodes, add:

[blazil]
aeron_ipc_dir    = "/dev/shm/aeron"
tigerbeetle_addr = "127.0.0.1:3000"
cluster_id       = 0

Running the node

./fc-node --config /etc/feedable/feedable.toml

On first start, the node will sync from genesis. Watch for:

INFO feedable_network::p2p: Connected to 3 peers
INFO feedable_network::consensus: Synced to height 10001
INFO feedable_network::consensus: PoF mandatory — Proof of Feed active

Height 10001 is the transition from genesis PoS to full Proof of Feed. At this point, miners must have Blazil running to produce valid blocks.

gRPC API

The fc-rpc crate exposes a gRPC service at port 9090. The full proto definitions are at proto/feedable/v1/.

Get latest block:

grpcurl -plaintext localhost:9090 feedable.v1.Node/GetLatestBlock

Submit a transaction:

grpcurl -plaintext -d '{
  "from": "base64_pubkey",
  "to": "base64_pubkey",
  "amount": 1000000,
  "fee": 1000
}' localhost:9090 feedable.v1.Node/SubmitTx

Submit an inference job:

grpcurl -plaintext -d '{
  "model_id": "base64_model_id",
  "input_cid": "base64_input_cid",
  "max_latency_ms": 50,
  "sla_tier": "NORMAL",
  "max_fee": 10000
}' localhost:9090 feedable.v1.Inference/SubmitJob

Retrieve inference result:

curl http://localhost:8080/data/{cid}

The data API serves raw bytes for any CID in the last 1,000 blocks. This endpoint is also used by the challenge protocol for re-verification.

Monitoring

The Prometheus endpoint at port 9100 exposes standard Go and Rust process metrics plus Feedable-specific metrics:

  • feedable_blocks_produced_total — blocks the node has produced
  • feedable_proofs_generated_total — FeedProofs generated (miner only)
  • feedable_slash_events_total — slash events observed on-chain
  • feedable_inference_latency_ms — histogram of inference latencies (miner only)
  • feedable_bft_round_duration_ms — BFT round completion times

A Grafana dashboard definition is at infra/grafana/feedable.json.

Current devnet status

The devnet is running locally at Kolerr Lab on an Apple M4. It is not yet publicly accessible. Public devnet endpoints will be available before testnet launch.

Current measured performance:

  • BFT finality: 66µs (3-node, localhost)
  • Inference latency: 1.335ms for 1,595-byte request
  • Block height: growing from genesis

What comes next

The roadmap from here:

v0.4 — fc-p2p hardening. Public peer discovery. First external nodes joining devnet.

v0.5 — fc-rpc public endpoint. The gRPC API accessible without running a local node.

v0.6 — Full devnet with SLA enforcement and slashing live. First challenge protocol execution.

v1.0 — Testnet launch. Public, incentivized. Genesis block with real F in circulation.

The full codebase, including this blog post, is at github.com/feedable-network-lab/feedable-blockchain-coin. Issues and PRs welcome.