mako ⚡

⚠️ Experimental — pre-1.0. APIs change between releases. Do not run it in
production without thorough in-house testing against your own counterparties.

mako is an open-source market-operations platform for the German energy
market, in Rust. It takes BDEW Marktkommunikation (MaKo) from raw EDIFACT and
AS4 bytes to event-sourced workflows that answer inside their Frist, and carries
metering, grid and EEG settlement, retail billing and the ledger on the same
events — for the NB, LF, MSB and ESA roles. The BDEW formats are read from the
published MIG and AHB documents as data, so a format release is an import run,
not a rewrite.

Quick start

From a fresh clone (Rust via rustup, just,
Docker for PostgreSQL), run one service:

git clone https://github.com/hupe1980/mako.git && cd mako
just dev marktd                    # PostgreSQL from dev/docker-compose.yml, then marktd
curl -s localhost:8180/health/ready

Every service has a dev/config/<service>.toml; makod needs no database.
<service> --help prints the config conventions, and a broken config names
every missing, unknown or invalid key at once.

Or run a whole stack — three demos under demos/, each a
docker compose file plus a smoke.sh that asserts every step:

just build-demo && cd demos/nb-stp && docker compose up -d && bash smoke.sh

just build-demo-eeg and just build-demo-o2c build the other two; they
compile the whole workspace, so budget 20–45 minutes cold. The
Getting Started guide
walks the first demo step by step.

Architecture

flowchart LR
    subgraph Market["Regulated market"]
        MP["Counterparty MSH<br/>(NB · LF · MSB · ÜNB)"]
    end

    subgraph Transport["Transport & process"]
        MAKOD["makod<br/>AS4 sign+encrypt · UNB…UNZ<br/>signed receipts · PID router"]
        PROCESSD["processd<br/>STP decisions"]
        MARKTD["marktd<br/>Market Data Hub"]
        SPERRD["sperrd<br/>Sperrung tracking"]
    end

    subgraph Settlement["Settlement & billing"]
        EDMD["edmd<br/>meter data · § 60 Abs. 1 MsbG"]
        NETZB["netzbilanzd<br/>NNE · MMM"]
        EINSD["einsd<br/>EEG/KWKG"]
        BILLINGD["billingd<br/>retail billing · risk gate"]
        INVOICD["invoicd<br/>INVOIC checking"]
        MABIS["mabis-syncd<br/>MaBiS 13003"]
        PRODUCTD["productd<br/>product catalog · EPEX"]
    end

    subgraph Business["Customer & operations"]
        VERTRAGD["vertragd<br/>contracts · §40b cadence<br/>§41e Aggregatorverträge"]
        ACCOUNTINGD["accountingd<br/>FI-CA ledger"]
        OUTPUTD["outputd<br/>customer documents<br/>+ delivery"]
        PORTALD["portald<br/>customer portal"]
        OBSD["obsd<br/>BNetzA KPIs"]
        AGENTD["agentd<br/>28 specialists<br/>26 model-backed + 2 coded"]
        ERP["ERP / operator systems"]
    end

    MP <-->|"AS4/ebMS3 · EDIFACT"| MAKOD
    MAKOD --> PROCESSD --> MARKTD
    MARKTD --> EDMD --> NETZB & EINSD & BILLINGD & MABIS
    MAKOD --> INVOICD
    PRODUCTD --> BILLINGD
    BILLINGD --> ACCOUNTINGD
    BILLINGD --> OUTPUTD
    VERTRAGD --> BILLINGD
    PROCESSD --> SPERRD
    EDMD & VERTRAGD --> PORTALD
    MAKOD -.->|"de.mako.*"| OBSD
    MAKOD & BILLINGD & EDMD -.->|"CloudEvents"| AGENTD
    AGENTD -.->|"de.agent.decision.made"| ERP
    ACCOUNTINGD --> ERP

Crates

Each crate's README carries its scope, PIDs and regulatory sources.

Services

Seventeen daemons, one PostgreSQL schema each; the operator reference — routes,
config, deployment — is mako docs · Services.

Use a crate

cargo add edi-energy

use edi_energy::{parse, EdiEnergyMessage};

let msg = parse(&std::fs::read("Netznutzung_20241015.edi")?)?;
let report = msg.validate()?;           // MIG + AHB + semantic rules
println!("valid: {}", report.is_valid());

use mako_engine::{builder::EngineBuilder, event_store::InMemoryEventStore, process::RunOptions};
use mako_gpke::lf_anmeldung::GpkeLfAnmeldungWorkflow;

let ctx = EngineBuilder::new().with_event_store(InMemoryEventStore::new()).build();
let tenant = mako_engine::ids::TenantId::new();        // `define_id!` newtype
let process = ctx.spawn::<GpkeLfAnmeldungWorkflow>(tenant, wf_id);
process.run(initiate_cmd, RunOptions::new()).await?;
let state = process.state().await?;     // replayed from the stored events

use dvgw_edi::DvgwPlatform;

let msg = DvgwPlatform::default().parse(edi_bytes)?;   // identity from BGM DE 1001
println!("{:?} {:?}", msg.gas_day(), msg.process_key());

use redispatch_xml::parse_and_validate;

let doc = parse_and_validate(xml_bytes)?;              // XSD + semantic rules
println!("{} from {}", doc.mrid(), doc.sender_id());

use mako_markt::domain::{MaloId, MarktpartnerId, nad_agency_code};

let malo = MaloId::new("51238696012")?;               // check digit verified
let mp: MarktpartnerId = "9900357000004".parse()?;
assert_eq!(nad_agency_code(&mp), "293");               // BDEW-Codenummer

The Reference covers parsing,
validation, builders, AS4, DVGW and Redispatch; feature flags are in each
crate's README.

Develop

just            # list every recipe
just check      # cargo check, all targets and features
just test       # the whole suite (cargo-nextest when installed)
just test-db    # the real-PostgreSQL suites (testcontainers, needs Docker)
just ci         # the gate — run it as below; a pipe hides the exit code
just ci > ci.log 2>&1; echo EXIT:$?

CONTRIBUTING.md covers building, testing one crate,
running one service and the gate; AGENTS.md holds the domain
rules and conventions. The profiles under crates/edi-energy/profiles/ are
generated from the BDEW PDFs — fix the reader in xtask/src/bdew/ and run
cargo xtask import-profiles instead of editing JSON.

Documentation

hupe1980.github.io/mako — source under
site/, built with Zola.

Releases

A tag vX.Y.Z publishes the crates to crates.io and the makotest wheels to
PyPI (Trusted Publishing), pushes the 17 service images to
ghcr.io/hupe1980/mako-<service>, and attaches the evidence pack, a CycloneDX
SBOM per service binary and the VEX document to the GitHub Release. Every image
and binary carries build-provenance and SBOM attestations:

gh attestation verify oci://ghcr.io/hupe1980/mako-makod:X.Y.Z --repo hupe1980/mako

See What a release carries
and SECURITY.md.

Contributing

Contributions are welcome; open an issue before a large change, and run
just ci before a pull request.

License

Licensed under either of MIT or
Apache 2.0, at your option.

Related crates

• edifact-rs — the EDIFACT parser underneath edi-energy
• asx-rs — AS4/ebMS3 transport used by makod
• rubo4e — BO4E business-object types
• metering and meterstore — metering domain and time-series store beneath edmd
• doubleentry — the ledger beneath accountingd
• billing — the EN 16931 tariff/invoicing engine under the settlement crates
• SlateDB — embedded storage behind mako-engine