a437feb8ab
openpay/
compliance/ PCI-DSS readiness package (scope-map,
pci-zero-architecture, hsm-kms-guidance,
qsa-checklist), citing PCI-DSS v4.0.1
requirements. (#1)
examples/pci-zero/ Runnable example demonstrating a deployment
where merchant code never touches a PAN. (#1)
crates/op-core/ Tokenized<Card> typestate + NetworkToken
+ CardNetwork + Cryptogram. (#2)
crates/op-rails-card/network_token/
NetworkTokenProvider trait + VTS adapter
+ MDES adapter, with deterministic stubs
behind a 'live' feature flag. (#2)
crates/op-driver-sdk/conformance/network_token.rs
Conformance harness for third-party
NetworkTokenProvider implementations. (#2)
crates/op-cli/src/ledger/ 'openpay ledger as-of' subcommand for
bi-temporal queries. (#3)
crates/op-orchestrator/src/telemetry.rs
OpenTelemetry span emission per
Payment<S> transition with semantic-
conventions tags. (#3)
docs/observability/ Grafana dashboard JSON + wiring guide
for the bi-temporal ledger lens. (#3)
smart-byte/
smart-byte-rs/ Rust reference implementation: envelope
encode/decode (canonical CBOR + BLAKE3
content addressing), Ed25519 sign +
verify, lockstep BFT commit MVP, Iroh
transport scaffold, CLI. (#4)
spec/identity_and_key_rotation.md
Adopts KERI SAIDs + key-event log
format; explicitly does not adopt ACDC
chaining wholesale. (#5)
conformance/v1/ 21 test vectors covering canonicalisation,
SAID computation, signature verification,
lockstep commit, gossip propagation.
CI gate enforces spec/vector coupling. (#6)
eoc/
eoc-rs/ Rust + WASM reference implementation:
4-stage cascade (cache -> kv -> graph ->
neural), joule counters via RAPL / NVML /
powermetrics, CLI, wasm-bindgen surface.
18 tests pass. (#7)
eoc-bench/ Benchmark harness, MT-Bench and Router
case sets, 'joules per MT-Bench point'
metric, 'eoc-bench run | compare' CLI. (#8)
standards/sci-for-ai-submission.md
Submission proposal mapping EOC's
receipt schema to GSF SCI-for-AI. (#9)
cookbook/ HuggingFace-style cookbook (markdown +
runnable Python) demonstrating EOC's
cascade with HF AI Energy Score. (#9)
docs/bench-v0.md Reproducibility doc for eoc-bench.
Workspace state:
- openpay clippy -- -D warnings: clean across all touched crates
- smart-byte-rs cargo test --workspace + clippy: clean
- eoc-rs cargo test --workspace + clippy: clean (18 tests)
- eoc-bench cargo check --workspace + clippy + 15 tests: clean
Rust 1.95.0 edition 2024 pinned at the open-standards root via
rust-toolchain.toml; every workspace inherits.
Closes #1 #2 #3 #4 #5 #6 #7 #8 #9.
78 lines
3.3 KiB
Markdown
78 lines
3.3 KiB
Markdown
# `eoc-rs` — EOC reference implementation in Rust
|
|
|
|
Apache-2.0 reference implementation of the **Energy-Optimized Compute** specification (CC-BY-4.0 spec lives in [`../spec/`](../spec/)).
|
|
|
|
EOC is a four-stage memoizing cascade. Every query is tried at each stage in turn and the first that can answer wins. The four stages, cheapest to most expensive, are:
|
|
|
|
1. **Cache** (`eoc-cache`) — content-addressed LRU. Cache hits are nearly free.
|
|
2. **Key-value** (`eoc-kv`) — exact key match plus cosine-similarity embedding match.
|
|
3. **Graph** (`eoc-graph`) — triple-store retrieval. Reference impl is a small in-memory matcher; production deployments swap in a real graph backend driven by DCY (EOC-4).
|
|
4. **Neural** (`eoc-neural`) — last-resort inference. Reference impl ships an `EchoBackend`; production deployments wire in llama.cpp / Ollama / Anthropic API / etc.
|
|
|
|
Joule cost is the unit of accounting. The `eoc-meter` crate reads cumulative micro-joules from whatever hardware counter is available (Linux RAPL, macOS `powermetrics`, NVIDIA NVML behind the `cuda` feature) and falls back to a `StubCounter` everywhere else — including WASM.
|
|
|
|
## Workspace layout
|
|
|
|
| Crate | Purpose |
|
|
|----------------|--------------------------------------------------------------|
|
|
| `eoc-core` | Types: `Query`, `Response`, `Stage`, `JouleCost`, `Receipt`. |
|
|
| `eoc-cache` | Stage 1 — LRU cache + the `Stage` trait. |
|
|
| `eoc-kv` | Stage 2 — KV + embedding-similarity lookup. |
|
|
| `eoc-graph` | Stage 3 — in-memory triple store. |
|
|
| `eoc-neural` | Stage 4 — neural inference trait + `EchoBackend`. |
|
|
| `eoc-meter` | Hardware energy counters with stub fallback. |
|
|
| `eoc-cascade` | Glue: walks the four stages, attributes joule cost. |
|
|
| `eoc` | Reference CLI. |
|
|
| `eoc-wasm` | `wasm-bindgen` wrapper — browser-runnable cascade. |
|
|
|
|
## Running
|
|
|
|
```sh
|
|
cargo test --workspace
|
|
cargo clippy --workspace --all-targets
|
|
cargo run --bin eoc -- query "what is 2+2"
|
|
cargo run --bin eoc -- meter
|
|
```
|
|
|
|
Example output:
|
|
|
|
```
|
|
$ cargo run --bin eoc -- query "what is 2+2"
|
|
stage : kv
|
|
payload: 4
|
|
cost : 50 µJ (estimated)
|
|
receipt: <64-char hex>
|
|
```
|
|
|
|
## CUDA / NVML
|
|
|
|
NVIDIA NVML support is feature-gated and **off by default** so the workspace builds without `libnvidia-ml`. To enable:
|
|
|
|
```sh
|
|
cargo build -p eoc-meter --features cuda
|
|
```
|
|
|
|
## WASM
|
|
|
|
The cascade compiles to `wasm32-unknown-unknown`. The meter does not — RAPL, NVML, and `powermetrics` are all absent in the browser, so WASM builds use `StubCounter` and report estimated joule cost.
|
|
|
|
```sh
|
|
rustup target add wasm32-unknown-unknown
|
|
cargo build -p eoc-wasm --target wasm32-unknown-unknown --release
|
|
wasm-bindgen target/wasm32-unknown-unknown/release/eoc_wasm.wasm \
|
|
--out-dir ./pkg --target web
|
|
```
|
|
|
|
Then from JavaScript:
|
|
|
|
```js
|
|
import init, { WasmCascade } from "./pkg/eoc_wasm.js";
|
|
await init();
|
|
const cascade = new WasmCascade();
|
|
const r = await cascade.resolve("ping");
|
|
console.log(r); // { stage: "kv", payload: "pong", microjoules: 50, ... }
|
|
```
|
|
|
|
## License
|
|
|
|
Apache-2.0 for the Rust source in this workspace. The EOC specification text in [`../spec/`](../spec/) is CC-BY-4.0. See [`../LICENSE`](../LICENSE).
|