Power House

Power House is a deterministic verification and provenance system for portable computational identities.

.pha artifacts provide self-verifying identity containers with deterministic fingerprints that bind proof data, provenance metadata, and verification state.

Rootprint provides a directed acyclic graph (DAG) for identity lineage, branching, merging, replay, navigation, and equivalence verification.

Current release: v0.3.7

The primary workflow is Power House Identity + Rootprint:

Identity provides immutable create, fork, merge, verify, replay, and equivalence operations over .pha and Rootprint.
Power House Archive (.pha) binds proof data and provenance to a deterministic phx_fingerprint.
Rootprint provides verifiable navigation, forks, merges, and equivalence over .pha core identities.
External proof attachments (EPA) are optional transport data and remain outside the Power House core fingerprint and Rootprint branch identity.
Observatory sidecars optionally bind human-readable semantic packets to verified Rootprint replay state without changing proof identity.

Quick Start

cargo add power_house

use power_house::{prove_with_rootprint, provenance::PhaArtifact};
use serde_json::json;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let artifact = PhaArtifact::new(
        json!({"producer": "example"}),
        "power-house/example/v1",
        json!({"claim": 7}),
        json!({"accepted": true}),
    )?;

    let graph = prove_with_rootprint!(
        label: "main",
        artifact: artifact,
    )?;
    graph.verify()?;
    Ok(())
}

Install the julian CLI with the network feature:

cargo install power_house --features net

The primary identity commands are:

julian identity create main.pha --label main \
  --identity-output main.identity.json \
  --rootprint-output proof.rootprint.json
julian identity verify main.identity.json proof.rootprint.json
julian identity replay main.identity.json proof.rootprint.json

Human-Observable Proofs

slbit is an independent zero-dependency crate for luminous claims, semantic transcripts, and visualization packets. Power House remains the verification and provenance authority; slbit adds human-readable meaning beside it.

cargo add power_house
cargo add slbit
cargo run --example slbit_observatory

The optional sidecar can be verified offline:

julian observatory verify \
  proof.rootprint.json \
  proof.observatory.json

See the Power House + slbit Observatory guide for the complete Rust workflow, schemas, trust boundary, browser rendering, and conformance vectors.

Verification Profiles

Profile	Public statement	Verifier path	Reproduce
Constant sum-check	`2^70` Boolean points	70 field rounds	`cargo run --release --example sextillion_verify`
Seeded affine sum-check	`2^4096` Boolean points	4,096 field rounds	`cargo run --release --example hyperscale_affine`
Seeded sparse certificate	`2^1,000,000` Boolean points	`O(n + I log n)` deterministic replay	`cargo run --release --example sparse_record`
Committed sparse workload	External `PHSMv1` + `PHCPv1` files	Commitment-bound deterministic replay	`cargo run --release --example committed_workload`
Portable provenance	`.pha` core + Rootprint DAG	Fingerprint and graph replay	`cargo run --example rootprint_workflow`

Here n is the number of variables and I is the number of nonzero variable incidences. The proof modes operate on compact algebraic descriptions and do not allocate the expanded Boolean hypercube.

Core Formats

Format	Purpose
`.pha` v1	Portable proof, public inputs, provenance, and core fingerprint
Rootprint v1	Deterministic proof-history graph with forks and merges
Observatory sidecar v1	Non-core binding from replay state and branch IDs to semantic packets
`PHSPv1`	Seeded sparse polynomial certificate
`PHSMv1`	Canonical external sparse polynomial
`PHCPv1`	Certificate bound to a `PHSMv1` commitment

Rust and Python consume the same canonical vectors under conformance/. Mutation tests require core changes to reject while proving that EPA mutation does not alter Power House core validity.

Reproduce

cargo fmt --check
cargo clippy --all-targets --all-features -- -D warnings
RUSTDOCFLAGS="-D warnings" cargo doc --all-features --no-deps
cargo test --all-targets --locked
cargo test --all-targets --features net --locked

cargo run --example pha_conformance_vectors
cargo run --example slbit_conformance_vectors
cargo run --example rootprint_workflow
cargo run --example slbit_observatory
cargo run --release --example sextillion_verify
cargo run --release --example hyperscale_affine
cargo run --release --example sparse_record
cargo run --release --example committed_workload

PYTHONPATH=sdk/python python3 -m unittest discover -s sdk/python/tests -v
python3 scripts/test_sparse_verifier.py
python3 scripts/test_observatory_contract.py
python3 scripts/soundness_budget.py

The complete procedure and expected rejection behavior are documented in the Verification Guide.

Primary Rust APIs

Identity: immutable .pha and Rootprint identity abstraction.
PhaArtifact: portable Power House core identity.
Rootprint: deterministic proof-history branching and verification.
ObservatorySidecar: non-core semantic packet binding to verified Rootprint replay state.
prove_with_rootprint!: recommended provenance-aware construction interface.
GeneralSumProof: dense, streaming, constant, and seeded-affine sum-check.
SeededSparseProof: stable PHSPv1 certificates.
CommittedSparsePolynomial and CommittedSparseProof: external workload binding.
ProofLedger: transcript logs, anchors, and quorum reconciliation.
ValidatorRegistry: signed identity admission and monitoring discovery records.

Python SDK

The bundled zero-dependency Python SDK defaults to pure Power House + Rootprint:

from power_house import create_artifact, new_rootprint, verify_rootprint

artifact = create_artifact(
    {"source": "python"},
    "power-house/example/v1",
    {"claim": 7},
    {"accepted": True},
)
graph = new_rootprint("main", artifact)
verify_rootprint(graph)

EPA helpers require an explicit secondary import:

from power_house.external import attach_external_proof

See SDKs for installation and interoperability tests.

Network And RPC

The optional net feature enables libp2p transport, signed envelopes, data availability services, governance policies, stake accounting, migration tools, and a quorum-finalized native JSON-RPC lane.

Public network	Value
RPC name	LAX MFENX RPC
Chain ID	`177155` (`0x2b403`)
Canonical endpoint	`https://rpc.mfenx.com`
ChainList endpoint	`https://rpc.mfenx.com`
Status	`https://mfenx.com/status.html`

The production edge uses health-aware global routing across validators in New York, San Francisco, and Amsterdam. Public traffic is rate-limited at Nginx and removed from a backend automatically when /healthz fails. Signed validator registrations bind each admitted public key to its derived peer ID and live identity metrics; validator totals are not inferred from peer links.

julian net start \
  --node-id validator-1 \
  --log-dir ./logs/validator-1 \
  --blob-dir ./data/validator-1 \
  --listen /ip4/0.0.0.0/tcp/7001 \
  --policy ./configs/governance.stake.json \
  --quorum 2 \
  --evm-chain-id 177155 \
  --evm-rpc-listen 127.0.0.1:8545 \
  --key ed25519://<seed>

Use scripts/test_native_rpc_cluster.sh to verify replica finality and scripts/check_rpc.py to run the external publication gate.

Documentation

Start with the Documentation Index.

Public Surfaces

API documentation: https://docs.rs/power_house
Package: https://crates.io/crates/power_house
Repository: https://github.com/JROChub/power_house
Public verifier: https://mfenx.com
Network status: https://mfenx.com/status.html

License

Power House v0.3.6 and later is licensed under AGPL-3.0-only. Earlier releases retain their original licenses; see LICENSE-CHANGE.md.

power_house 0.3.7