nedb-engine 2.2.31__tar.gz → 2.2.32__tar.gz

{nedb_engine-2.2.31 → nedb_engine-2.2.32}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nedb-engine
-Version: 2.2.31
+Version: 2.2.32
 Summary: NEDB — a versioned, self-compressing, time-traveling embedded database (replay-protected, idempotent, relational, searchable) with durable AOF persistence and a server daemon (nedbd).
 Project-URL: Homepage, https://github.com/aiassistsecure/nedb
 Project-URL: Repository, https://github.com/aiassistsecure/nedb
@@ -29,8 +29,9 @@ Replay-protected · idempotent · relational · filterable · sortable · search
 One Rust core → ships to **PyPI** and **npm** from a single source.
 
 [![PyPI](https://img.shields.io/pypi/v/nedb-engine?label=PyPI&color=6366f1)](https://pypi.org/project/nedb-engine/)
+[![crates.io](https://img.shields.io/crates/v/nedb-engine?label=crates.io&color=f97316)](https://crates.io/crates/nedb-engine)
 [![npm](https://img.shields.io/npm/v/nedb-engine?label=npm&color=00d4ff)](https://www.npmjs.com/package/nedb-engine)
-[![Tests](https://img.shields.io/badge/tests-266%20passing-34d399)](https://github.com/aiassistsecure/nedb/actions)
+[![CI](https://img.shields.io/github/actions/workflow/status/Eth-Interchained/nedb/release.yml?label=CI&color=34d399)](https://github.com/Eth-Interchained/nedb/actions)
 [![nedb-engine-client PyPI](https://img.shields.io/pypi/v/nedb-engine-client?label=nedb-engine-client&color=34d399)](https://pypi.org/project/nedb-engine-client/)
 [![nedb-engine-client npm](https://img.shields.io/npm/v/nedb-engine-client?label=nedb-engine-client&color=34d399)](https://www.npmjs.com/package/nedb-engine-client)
 

{nedb_engine-2.2.31 → nedb_engine-2.2.32}/README.md

@@ -8,8 +8,9 @@ Replay-protected · idempotent · relational · filterable · sortable · search
 One Rust core → ships to **PyPI** and **npm** from a single source.
 
 [![PyPI](https://img.shields.io/pypi/v/nedb-engine?label=PyPI&color=6366f1)](https://pypi.org/project/nedb-engine/)
+[![crates.io](https://img.shields.io/crates/v/nedb-engine?label=crates.io&color=f97316)](https://crates.io/crates/nedb-engine)
 [![npm](https://img.shields.io/npm/v/nedb-engine?label=npm&color=00d4ff)](https://www.npmjs.com/package/nedb-engine)
-[![Tests](https://img.shields.io/badge/tests-266%20passing-34d399)](https://github.com/aiassistsecure/nedb/actions)
+[![CI](https://img.shields.io/github/actions/workflow/status/Eth-Interchained/nedb/release.yml?label=CI&color=34d399)](https://github.com/Eth-Interchained/nedb/actions)
 [![nedb-engine-client PyPI](https://img.shields.io/pypi/v/nedb-engine-client?label=nedb-engine-client&color=34d399)](https://pypi.org/project/nedb-engine-client/)
 [![nedb-engine-client npm](https://img.shields.io/npm/v/nedb-engine-client?label=nedb-engine-client&color=34d399)](https://www.npmjs.com/package/nedb-engine-client)
 

{nedb_engine-2.2.31 → nedb_engine-2.2.32}/pyproject.toml

@@ -10,7 +10,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "nedb-engine"
-version = "2.2.31"
+version = "2.2.32"
 description = "NEDB — a versioned, self-compressing, time-traveling embedded database (replay-protected, idempotent, relational, searchable) with durable AOF persistence and a server daemon (nedbd)."
 readme = "README.md"
 requires-python = ">=3.8"

{nedb_engine-2.2.31 → nedb_engine-2.2.32}/python/nedb/__init__.py

@@ -29,6 +29,7 @@ from .mongo import (
 from .autoindex import AutoIndexDB
 from .concurrent import Sequencer
 from .wrap_redis import wrap_redis, WrappedRedis
+from .proof import verify_proof, fold_head
 
 try:  # compiled Rust core, present in platform wheels (PyO3 via maturin)
     from . import _native  # type: ignore
@@ -85,6 +86,7 @@ __all__ = [
     "MongoCompat", "MongoClient", "MongoError", "MongoUnsupportedError", "ObjectId",
     "AutoIndexDB", "Sequencer",
     "wrap_redis", "WrappedRedis",
+    "verify_proof", "fold_head",
     "_native", "__has_native__",
 ]
-__version__ = "2.2.31"
+__version__ = "2.2.32"

nedb_engine-2.2.32/python/nedb/proof.py

@@ -0,0 +1,126 @@
+"""
+nedb.proof — Merkle inclusion proofs for the hash-chained op log.
+
+Every NEDB write produces an Op whose ``hash`` field is the chain head after that op
+(``op.hash = blake2b(prev_head.utf8 + canon(body))`` — see ``nedb.log``). The chain
+head therefore commits cryptographically to the entire write history.
+
+This module derives a *parallel*, compact Merkle commitment chain over the same
+op-hash sequence so a client can verify — offline, with no server round-trip and
+without re-running the engine — that a specific op-hash was at a specific seq in
+the log, and that the log's head followed from chaining all subsequent op-hashes
+on top of it.
+
+The chain step used by both ``verify_proof`` (client) and the server endpoint is::
+
+    head_next = blake2b(bytes.fromhex(head_prev) || bytes.fromhex(op_hash)).hexdigest()
+
+starting from the genesis head (the all-zero 32-byte string). Folding over the
+full ordered list of op-hashes yields a deterministic head; tamper with any op
+hash (or reorder ops) and the fold no longer matches. The Op's own ``hash`` field
+already commits to its body (payload, seq, nonce, ts, …) under the engine's chain
+formula, so this fold is a complete commitment to the write history through the
+op-hashes alone — exactly the property a Merkle inclusion proof needs.
+
+The fold's terminal value (``proof["head"]``) is a *derived* head, distinct from
+``db.head`` (the engine's UTF-8-hex chain) but a deterministic function of the
+same log. The server computes the derived head over the live log when issuing
+each proof, so any divergence between client fold and server fold means the
+proof was tampered with in transit.
+"""
+from __future__ import annotations
+
+import hashlib
+from typing import Dict, List
+
+# Genesis head matches the engine: all-zero 32-byte string in hex.
+GENESIS = "0" * 64
+
+
+def _blake(data: bytes) -> str:
+    """BLAKE2b-256 over raw bytes, returned as hex — same primitive the engine uses."""
+    return hashlib.blake2b(data, digest_size=32).hexdigest()
+
+
+def _chain_step(head_hex: str, op_hash_hex: str) -> str:
+    """One Merkle-chain step on raw bytes (decoded from hex).
+
+    Mirrors the user-facing spec exactly:
+        new_head = blake2b(prev_head_bytes || op_hash_bytes)
+    """
+    return _blake(bytes.fromhex(head_hex) + bytes.fromhex(op_hash_hex))
+
+
+def fold_head(op_hashes: List[str], start: str = GENESIS) -> str:
+    """Fold an ordered list of op-hashes into a Merkle-chain head.
+
+    Used by the server to produce ``proof["head"]`` for any given log state and
+    by tests to sanity-check that the fold is order-sensitive and deterministic.
+    """
+    head = start
+    for h in op_hashes:
+        head = _chain_step(head, h)
+    return head
+
+
+def verify_proof(proof: Dict) -> bool:
+    """Verify a Merkle inclusion proof client-side — no server, no engine needed.
+
+    ``proof`` shape::
+
+        {
+            "hash":       "<64-hex>",   # the document op's content hash (op.hash)
+            "seq":        N,            # sequence number of this op in the log
+            "prev_head":  "<64-hex>",   # chain head BEFORE this op (= op.prev_hash)
+            "subsequent": ["<64-hex>"], # op-hashes of every op AFTER this one
+            "head":       "<64-hex>",   # claimed final (derived) chain head
+        }
+
+    Verification (matches the spec):
+      1. ``head_at_seq = blake2b(prev_head_bytes || hash_bytes)``
+      2. For each ``sub_hash`` in subsequent:
+            ``head = blake2b(head_bytes || sub_hash_bytes)``
+      3. ``final head == proof["head"]``
+
+    Returns True iff every step is internally consistent. Tampering with any
+    field — flipping a byte of ``hash``, reordering ``subsequent``, swapping
+    ``prev_head``, etc. — will flip the fold and make this return False.
+    """
+    if not isinstance(proof, dict):
+        return False
+
+    # Required keys with the right shapes.
+    required = ("hash", "seq", "prev_head", "subsequent", "head")
+    if not all(k in proof for k in required):
+        return False
+    if not isinstance(proof["seq"], int) or proof["seq"] < 0:
+        return False
+    if not isinstance(proof["subsequent"], list):
+        return False
+
+    # Hex shape check on the 64-char fields. Anything malformed → not verified.
+    def _is_hex32(s: object) -> bool:
+        if not isinstance(s, str) or len(s) != 64:
+            return False
+        try:
+            bytes.fromhex(s)
+        except ValueError:
+            return False
+        return True
+
+    if not _is_hex32(proof["hash"]):       return False
+    if not _is_hex32(proof["prev_head"]):  return False
+    if not _is_hex32(proof["head"]):       return False
+    for s in proof["subsequent"]:
+        if not _is_hex32(s):
+            return False
+
+    # 1. Re-derive the chain head AT this op's seq from prev_head + this op's hash.
+    head = _chain_step(proof["prev_head"], proof["hash"])
+
+    # 2. Fold each subsequent op-hash on top to advance the chain to the tail.
+    for sub in proof["subsequent"]:
+        head = _chain_step(head, sub)
+
+    # 3. The fold must equal the claimed final head bit-for-bit.
+    return head == proof["head"]

{nedb_engine-2.2.31 → nedb_engine-2.2.32}/python/nedb/server.py

@@ -33,6 +33,7 @@ HTTP API (all JSON):
   POST   /v1/databases/<name>/files             {name, data_b64, tier?}  — store a file (Cascade-compressed)
   GET    /v1/databases/<name>/files/<filename>?version=N&tier=warm  — retrieve a file
   GET    /v1/databases/<name>/files/<filename>/root?version=N&tier=warm  — Merkle root (anchorable)
+  POST   /v1/databases/<name>/proof             {hash}  — Merkle inclusion proof (verifiable offline)
   POST   /v1/databases/<name>/checkpoint        — on-demand checkpoint
   GET    /v1/databases/<name>/batch             — batch writes (array of {op,coll,id,doc})
 """
@@ -368,6 +369,57 @@ def make_handler(manager: Manager, token: Optional[str]):
                         ops = [o.to_dict() for o in db.log.ops[-limit:]][::-1]
                         self._send(200, {"log": ops, "seq": db.seq, "head": db.head})
                         return
+                    # POST /v1/databases/<name>/proof
+                    # Body: {"hash": "<64-hex>"}  — the op.hash of a previously-written doc
+                    # Response: a self-contained Merkle inclusion proof + a verified flag.
+                    # The proof is verifiable client-side via nedb.verify_proof() with no
+                    # server / engine — the server's role is only to look up the seq,
+                    # collect the prev_head and subsequent op-hashes, and fold them into
+                    # the same derived head the client will re-derive locally.
+                    if method == "POST" and action == "proof":
+                        from .proof import verify_proof as _vp, fold_head as _fold, GENESIS as _GEN
+                        b = self._body()
+                        want = str(b.get("hash", "")).strip().lower()
+                        if not want or len(want) != 64:
+                            raise HttpError(400, "hash (64-char hex) is required")
+                        try:
+                            bytes.fromhex(want)
+                        except ValueError:
+                            raise HttpError(400, "hash must be 64-char hexadecimal")
+                        # Find the Op with this exact chain-hash.
+                        ops = db.log.ops
+                        target = None
+                        for o in ops:
+                            if o.hash == want:
+                                target = o
+                                break
+                        if target is None:
+                            raise HttpError(404, f"no op with hash={want[:16]}…")
+                        # The proof scheme is a Merkle fold over op-hashes — a
+                        # PARALLEL commitment to the engine's per-op chain. Both
+                        # are deterministic functions of the same log. Replay the
+                        # fold from GENESIS to determine the fold-value just before
+                        # this op (prev_head), then collect every subsequent op-hash
+                        # so the client can fold forward to the same derived head.
+                        op_hashes = [o.hash for o in ops]
+                        prev_head  = _fold(op_hashes[: target.seq], start=_GEN)
+                        subsequent = op_hashes[target.seq + 1:]
+                        derived_head = _fold(op_hashes, start=_GEN)
+                        proof = {
+                            "hash":       target.hash,
+                            "seq":        target.seq,
+                            "prev_head":  prev_head,
+                            "subsequent": subsequent,
+                            "head":       derived_head,
+                        }
+                        # Self-check: confirm the proof verifies before returning it,
+                        # so a 200 from this endpoint is a hard guarantee of soundness.
+                        proof["verified"] = _vp(proof)
+                        # Helpful extras for clients that want to anchor to db.head too.
+                        proof["engine_head"] = db.head
+                        proof["engine_seq"]  = db.seq
+                        self._send(200, proof)
+                        return
                     # MongoDB-compatible query endpoint
                     # POST /v1/databases/<name>/mongo
                     # Body: {collection, op, ...op-specific args}

{nedb_engine-2.2.31 → nedb_engine-2.2.32}/rust/nedb-v2/README.md

@@ -3,8 +3,8 @@
 **NEDB v2 — content-addressed DAG storage engine with NQL and HTTP server**
 
 [![crates.io](https://img.shields.io/crates/v/nedb-engine?color=f97316)](https://crates.io/crates/nedb-engine)
-[![License: BUSL-1.1](https://img.shields.io/badge/license-BUSL--1.1-blue)](https://github.com/Eth-Interchained/nedb/blob/master/LICENSE)
-[![GitHub](https://img.shields.io/badge/github-Eth--Interchained%2Fnedb-8da0cb)](https://github.com/Eth-Interchained/nedb)
+[![License: BUSL-1.1](https://img.shields.io/badge/license-BUSL--1.1-blue)](https://github.com/aiassistsecure/nedb/blob/master/LICENSE)
+[![GitHub](https://img.shields.io/badge/github-aiassistsecure%2Fnedb-8da0cb)](https://github.com/aiassistsecure/nedb)
 
 This crate ships the **`nedbd`** binary — the NEDB v2 DAG HTTP server. Install it, point it at a data directory, and any language can speak to it over HTTP/JSON.
 
@@ -172,7 +172,7 @@ nedbd --doctor
 
 ## License
 
-[BUSL-1.1](https://github.com/Eth-Interchained/nedb/blob/master/LICENSE) — Business Source License. Free for development and evaluation; production use requires a commercial licence from INTERCHAINED, LLC.
+[BUSL-1.1](https://github.com/aiassistsecure/nedb/blob/master/LICENSE) — Business Source License. Free for development and evaluation; production use requires a commercial licence from INTERCHAINED, LLC.
 
 ---