snapkitty-sovereign-addr

Non-recursive artifact addressing for the SnapKitty ecosystem. Same semantic artifact. Same canonical bytes. Same sovereign address. Same WORM receipt.

---

Architecture

┌─────────────────────────────────────────────────────────────────┐
│                    SNAPKITTY SOVEREIGN ADDRESSING                │
├─────────────────────────────────────────────────────────────────┤
│                                                                  │
│   ┌──────────┐    ┌──────────────┐    ┌───────────────────┐    │
│   │ Artifact │───▶│ Admissibility│───▶│ Unicode NFC       │    │
│   │ (JSON)   │    │ Validator    │    │ Normalization     │    │
│   └──────────┘    └──────────────┘    └───────────────────┘    │
│                                              │                  │
│                                              ▼                  │
│   ┌──────────────────────────────────────────────────────────┐  │
│   │              SnapCanonical JSON Serialization             │  │
│   │         (sorted keys, no whitespace, deterministic)       │  │
│   └──────────────────────────────────────────────────────────┘  │
│                         │                                        │
│                         ▼                                        │
│   ┌──────────────────────────────────────────────────────────┐  │
│   │                    SHA-256 Hashing                        │  │
│   │              (64 lowercase hex chars)                     │  │
│   └──────────────────────────────────────────────────────────┘  │
│                         │                                        │
│                         ▼                                        │
│   ┌──────────────────────────────────────────────────────────┐  │
│   │              snapaddr:<64hex> Address                     │  │
│   └──────────────────────────────────────────────────────────┘  │
│                         │                                        │
│                         ▼                                        │
│   ┌──────────────────────────────────────────────────────────┐  │
│   │                   WORM Receipt                            │  │
│   │            (SHA-256 sealed, timestamped)                  │  │
│   └──────────────────────────────────────────────────────────┘  │
│                                                                  │
└─────────────────────────────────────────────────────────────────┘

Datalog Rules

artifact(A).
json_admissible(A).
nfc_ok(A, N).
snap_canonical(N, B).
sha256_digest(B, D).
snap_address(A, Addr) :-
    artifact(A),
    json_admissible(A),
    nfc_ok(A, N),
    snap_canonical(N, B),
    sha256_digest(B, D),
    concat("snapaddr:", D, Addr).

accepted(A, Addr) :-
    snap_address(A, Addr),
    not rejected(A, _).

rejected(A, "not_json_admissible") :-
    artifact(A),
    not json_admissible(A).

worm_receipt(A, Addr, Seal) :-
    accepted(A, Addr),
    receipt_bytes(A, Addr, R),
    sha256_digest(R, Seal).

Quick Start

Install

cargo install snapkitty-sovereign-addr

CLI Usage

# Compute sovereign address from JSON file
echo '{"prime": 42, "name": "test"}' | snapaddr encode
# Output: snapaddr:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855

# Generate WORM receipt
snapaddr receipt artifact.json
# Output: {"standard":"SNAPKITTY-SOVEREIGN-ADDR-1","algorithm":"snap-sha256-v1",...}

# Verify address
snapaddr verify artifact.json --address snapaddr:e3b0c442...

# Validate JSON admissibility
snapaddr validate artifact.json

Rust API

use snapkitty_sovereign_addr::{
    sovereign_address,
    sovereign_address_bytes,
    canonical_bytes,
    worm_receipt,
    verify_address,
    verify_receipt,
};

fn main() {
    let value = serde_json::json!({
        "prime": 42,
        "name": "test_operator",
        "metadata": {"version": "1.0"}
    });

    // Compute sovereign address
    let addr = sovereign_address(&value).unwrap();
    println!("Address: {}", addr);
    // Output: snapaddr:e3b0c44298fc1c149afbf4c8996fb924...

    // Compute raw address bytes
    let bytes = sovereign_address_bytes(&value).unwrap();
    println!("Bytes: {:?}", bytes);

    // Generate WORM receipt
    let receipt = worm_receipt(&value).unwrap();
    println!("Receipt: {}", serde_json::to_string_pretty(&receipt).unwrap());

    // Verify address
    assert!(verify_address(&value, &addr).unwrap());

    // Verify receipt
    assert!(verify_receipt(&receipt).unwrap());
}

Interactive Demo

# Demo 1: Key ordering invariance
$ echo '{"b": 2, "a": 1}' | snapaddr encode
snapaddr:7819c7f8a8b...

$ echo '{"a": 1, "b": 2}' | snapaddr encode
snapaddr:7819c7f8a8b...  # Same address!

# Demo 2: Unicode NFC equivalence
$ echo '{"name": "é"}' | snapaddr encode
snapaddr:a1b2c3d4...

$ echo '{"name": "\u0065\u0301"}' | snapaddr encode
snapaddr:a1b2c3d4...  # Same address!

# Demo 3: WORM receipt verification
$ snapaddr receipt test.json | jq .status
"accepted"

$ snapaddr receipt test.json | jq .seal
"snapaddr:e3b0c44298fc1c149afbf4c8996fb924..."

Algorithm

1. Validate JSON admissibility — non-recursive staged traversal
2. Normalize strings to Unicode NFC — canonical form
3. Serialize canonical JSON — sorted keys, no whitespace
4. Hash with SHA-256 — 64 lowercase hex chars
5. Emit snapaddr:<digest> — sovereign address
6. Generate WORM receipt — SHA-256 sealed, timestamped

Invariants

Invariant	Description
No Recursion	All validation is staged traversal, never recursive
Deterministic	Same input always produces same output
WORM Sealed	Every artifact is write-once, read-many
Fail-Closed	Any error terminates processing
Observable	Every intermediate state is inspectable

Testing

# Run all tests
cargo test

# Run property tests
cargo test properties

# Run with output
cargo test -- --nocapture

Receipt Shape

{
  "standard": "SNAPKITTY-SOVEREIGN-ADDR-1",
  "algorithm": "snap-sha256-v1",
  "canonicalization": "snapcanonical-json+nfc",
  "address": "snapaddr:e3b0c44298fc1c149afbf4c8996fb924...",
  "status": "accepted",
  "seal": "snapaddr:a1b2c3d4e5f6...",
  "governance": "agent-review-pending"
}

License

Sovereign Source License — see SOVEREIGN.md

---

SNAPADDR-NONREC-001
Normalize. Canonicalize. Hash. Seal. Govern.
Same artifact. Same address.
No recursion. No borrowed thesis.

---

Citation

If you use this work, please cite:

@misc{snapkittywest2026sovereigncompute,
  title = {SNAPKITTYWEST: Sovereign Compute Architecture with Linear Types, WORM Seals, and Goldilocks Field Arithmetic},
  author = {SnapKitty Collective},
  year = {2026},
  doi = {10.5281/zenodo.21132094},
  url = {https://doi.org/10.5281/zenodo.21132094}
}

Paper: https://doi.org/10.5281/zenodo.21132094 ORCID: https://orcid.org/0009-0006-1916-5245