uor-addr 0.2.0

UOR-ADDR — the typed reference vocabulary for content-addressing across recursively-grammared formats. Standard-library Layer-3 Prism realization of the UOR Foundation; ships the common architectural surface plus the JSON realization under JCS-RFC8785 + NFC + SHA-256.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

//! `uor-addr` — Signed cost-model variant comprehensive example.
//!
//! Demonstrates [`uor_addr::variant::signed`] — the
//! cost-model-bearing variant binding
//! `C = SingletonCommitment<UltrametricCloseTo<2>>` per ADR-048 +
//! ADR-049. Shows the ultrametric-proximity predicate behaviour,
//! the bandwidth measurement, the `TypedCommitment` surface, and
//! the architectural retargetability when
//! `prism::pipeline::SignatureCommitmentPredicate` is published.
//!
//! Run with `cargo run -p uor-addr --example signed_variant`.

use prism::pipeline::{ObservablePredicate, TypedCommitment, UltrametricCloseTo};
use uor_addr::variant::signed::{
    AddressSignedModel, AddressSignedRoute, SignedCommitment, SIGNATURE_PROXIMITY_K,
    SIGNATURE_REFERENCE, SIGNED_COMMITMENT_INSTANCE,
};

fn main() {
    println!("uor-addr — Signed cost-model variant (ADR-048 + ADR-049)\n");

    // 1. The bound C selection.
    println!("1. Cost-model binding");
    println!("   C = SingletonCommitment<UltrametricCloseTo<2>>");
    println!("   reference digest (32 bytes BE):");
    println!("     {:02X?}", SIGNATURE_REFERENCE);
    println!("   2-adic proximity threshold k = {SIGNATURE_PROXIMITY_K}");
    println!();

    // 2. Predicate evaluation — 2-adic ultrametric proximity.
    //    ν_2(d XOR reference) ≥ k iff the last k bits of d and
    //    reference agree.
    let predicate: UltrametricCloseTo<2> = UltrametricCloseTo {
        reference: SIGNATURE_REFERENCE,
        k: SIGNATURE_PROXIMITY_K,
    };
    let aligned: [u8; 32] = [0; 32];
    let mut last_bit_off: [u8; 32] = [0; 32];
    last_bit_off[31] = 0x01;
    let mut last_byte_off: [u8; 32] = [0; 32];
    last_byte_off[31] = 0xFF;
    println!("2. Predicate evaluation (2-adic ultrametric proximity, k = 1)");
    println!(
        "   all-zero digest    : {}",
        if predicate.evaluate(&aligned) {
            "ADMITTED"
        } else {
            "rejected"
        }
    );
    println!(
        "   LSB-flipped digest : {}",
        if predicate.evaluate(&last_bit_off) {
            "ADMITTED"
        } else {
            "rejected"
        }
    );
    println!(
        "   last-byte-FF digest: {}",
        if predicate.evaluate(&last_byte_off) {
            "ADMITTED"
        } else {
            "rejected"
        }
    );
    println!();

    // 3. Bandwidth measurement per ADR-048 + ADR-049.
    let bandwidth = SIGNED_COMMITMENT_INSTANCE.bandwidth_bits();
    println!("3. Bandwidth (ADR-048 + ADR-049)");
    println!("   bandwidth_bits = -log2(accept_prob)");
    println!("   accept_prob = 1 / 2^k = 0.5 for k = 1");
    println!("   bandwidth = {bandwidth:.6} bits");
    println!();

    // 4. TypedCommitment + PrismModel conformance at compile time.
    fn assert_typed_commitment<C: TypedCommitment>() {}
    assert_typed_commitment::<SignedCommitment>();
    fn assert_prism_model<
        'a,
        M: prism::pipeline::PrismModel<
            'a,
            prism::vocabulary::DefaultHostTypes,
            uor_addr::AddrBounds,
            uor_addr::Sha256Hasher,
            { uor_addr::ADDR_INLINE_BYTES },
            32,
            uor_addr::AddressResolverTuple<uor_addr::Sha256Hasher>,
            SignedCommitment,
            Route = AddressSignedRoute,
        >,
    >() {
    }
    assert_prism_model::<AddressSignedModel>();
    println!("4. Compile-time conformance");
    println!("   SignedCommitment: TypedCommitment ✓");
    println!("   AddressSignedModel: PrismModel<…, SignedCommitment> ✓");

    println!();
    println!("Note: ARCHITECTURE.md's architectural commitment is");
    println!("  C = SingletonCommitment<SignatureCommitmentPredicate>.");
    println!("This module binds UltrametricCloseTo<2> — the closest standing");
    println!("ObservablePredicate from prism::pipeline's published roster — until");
    println!("a SignatureCommitmentPredicate primitive lands. The architectural");
    println!("surface (the SingletonCommitment<…> shape) does not change.");

    println!("\nOK — Signed variant ships a non-default C per ADR-048.");
}