Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

Prove G004 contract bundles are machine-checkable

bellmane1641aa01047
diff --git a/rust/crates/runtime/src/g004_conformance.rs b/rust/crates/runtime/src/g004_conformance.rs
index 93621de5..88d42be7 100644
--- a/rust/crates/runtime/src/g004_conformance.rs
+++ b/rust/crates/runtime/src/g004_conformance.rs
@@ -63,12 +63,27 @@ fn validate_lane_events(value: Option<&Value>, path: &str, errors: &mut Vec<G004
let mut previous_seq = None;
for (index, event) in events.iter().enumerate() {
let base = format!("{path}/{index}");
- require_non_empty_string(event, &format!("{base}/event"), errors);
- require_non_empty_string(event, &format!("{base}/status"), errors);
- require_non_empty_string(event, &format!("{base}/emittedAt"), errors);
- require_non_empty_string(event, &format!("{base}/metadata/provenance"), errors);
- require_non_empty_string(event, &format!("{base}/metadata/emitterIdentity"), errors);
- require_non_empty_string(event, &format!("{base}/metadata/environmentLabel"), errors);
+ require_non_empty_string_at(event, "/event", &format!("{base}/event"), errors);
+ require_non_empty_string_at(event, "/status", &format!("{base}/status"), errors);
+ require_non_empty_string_at(event, "/emittedAt", &format!("{base}/emittedAt"), errors);
+ require_non_empty_string_at(
+ event,
+ "/metadata/provenance",
+ &format!("{base}/metadata/provenance"),
+ errors,
+ );
+ require_non_empty_string_at(
+ event,
+ "/metadata/emitterIdentity",
+ &format!("{base}/metadata/emitterIdentity"),
+ errors,
+ );
+ require_non_empty_string_at(
+ event,
+ "/metadata/environmentLabel",
+ &format!("{base}/metadata/environmentLabel"),
+ errors,
+ );
match get_path(event, "/metadata/seq").and_then(Value::as_u64) {
Some(seq) => {
@@ -89,7 +104,12 @@ fn validate_lane_events(value: Option<&Value>, path: &str, errors: &mut Vec<G004
}
if is_terminal_event_value(event.get("event")) {
- require_non_empty_string(event, &format!("{base}/metadata/eventFingerprint"), errors);
+ require_non_empty_string_at(
+ event,
+ "/metadata/eventFingerprint",
+ &format!("{base}/metadata/eventFingerprint"),
+ errors,
+ );
}
}
}
@@ -101,16 +121,32 @@ fn validate_reports(value: Option<&Value>, path: &str, errors: &mut Vec<G004Conf
for (index, report) in reports.iter().enumerate() {
let base = format!("{path}/{index}");
- require_string_eq(
+ require_string_eq_at(
report,
+ "/schemaVersion",
&format!("{base}/schemaVersion"),
REPORT_SCHEMA_VERSION,
errors,
);
- require_non_empty_string(report, &format!("{base}/reportId"), errors);
- require_non_empty_string(report, &format!("{base}/identity/contentHash"), errors);
- require_non_empty_string(report, &format!("{base}/projection/provenance"), errors);
- require_non_empty_string(report, &format!("{base}/redaction/provenance"), errors);
+ require_non_empty_string_at(report, "/reportId", &format!("{base}/reportId"), errors);
+ require_non_empty_string_at(
+ report,
+ "/identity/contentHash",
+ &format!("{base}/identity/contentHash"),
+ errors,
+ );
+ require_non_empty_string_at(
+ report,
+ "/projection/provenance",
+ &format!("{base}/projection/provenance"),
+ errors,
+ );
+ require_non_empty_string_at(
+ report,
+ "/redaction/provenance",
+ &format!("{base}/redaction/provenance"),
+ errors,
+ );
non_empty_array(
get_path(report, "/consumerCapabilities"),
&format!("{base}/consumerCapabilities"),
@@ -136,19 +172,21 @@ fn validate_findings(value: Option<&Value>, path: &str, errors: &mut Vec<G004Con
for (index, finding) in findings.iter().enumerate() {
let base = format!("{path}/{index}");
- require_one_of(
+ require_one_of_at(
finding,
+ "/kind",
&format!("{base}/kind"),
&["fact", "hypothesis", "negative_evidence"],
errors,
);
- require_one_of(
+ require_one_of_at(
finding,
+ "/confidence",
&format!("{base}/confidence"),
&["low", "medium", "high"],
errors,
);
- require_non_empty_string(finding, &format!("{base}/statement"), errors);
+ require_non_empty_string_at(finding, "/statement", &format!("{base}/statement"), errors);
}
}
@@ -163,10 +201,25 @@ fn validate_field_deltas(
for (index, delta) in deltas.iter().enumerate() {
let base = format!("{path}/{index}");
- require_non_empty_string(delta, &format!("{base}/field"), errors);
- require_non_empty_string(delta, &format!("{base}/previousHash"), errors);
- require_non_empty_string(delta, &format!("{base}/currentHash"), errors);
- require_non_empty_string(delta, &format!("{base}/attribution"), errors);
+ require_non_empty_string_at(delta, "/field", &format!("{base}/field"), errors);
+ require_non_empty_string_at(
+ delta,
+ "/previousHash",
+ &format!("{base}/previousHash"),
+ errors,
+ );
+ require_non_empty_string_at(
+ delta,
+ "/currentHash",
+ &format!("{base}/currentHash"),
+ errors,
+ );
+ require_non_empty_string_at(
+ delta,
+ "/attribution",
+ &format!("{base}/attribution"),
+ errors,
+ );
}
}
@@ -181,12 +234,17 @@ fn validate_approval_tokens(
for (index, token) in tokens.iter().enumerate() {
let base = format!("{path}/{index}");
- require_non_empty_string(token, &format!("{base}/tokenId"), errors);
- require_non_empty_string(token, &format!("{base}/owner"), errors);
- require_non_empty_string(token, &format!("{base}/scope"), errors);
- require_non_empty_string(token, &format!("{base}/issuedAt"), errors);
- require_bool_true(token, &format!("{base}/oneTimeUse"), errors);
- require_non_empty_string(token, &format!("{base}/replayPreventionNonce"), errors);
+ require_non_empty_string_at(token, "/tokenId", &format!("{base}/tokenId"), errors);
+ require_non_empty_string_at(token, "/owner", &format!("{base}/owner"), errors);
+ require_non_empty_string_at(token, "/scope", &format!("{base}/scope"), errors);
+ require_non_empty_string_at(token, "/issuedAt", &format!("{base}/issuedAt"), errors);
+ require_bool_true_at(token, "/oneTimeUse", &format!("{base}/oneTimeUse"), errors);
+ require_non_empty_string_at(
+ token,
+ "/replayPreventionNonce",
+ &format!("{base}/replayPreventionNonce"),
+ errors,
+ );
validate_delegation_chain(
get_path(token, "/delegationChain"),
&format!("{base}/delegationChain"),
@@ -206,10 +264,10 @@ fn validate_delegation_chain(
for (index, hop) in chain.iter().enumerate() {
let base = format!("{path}/{index}");
- require_non_empty_string(hop, &format!("{base}/from"), errors);
- require_non_empty_string(hop, &format!("{base}/to"), errors);
- require_non_empty_string(hop, &format!("{base}/action"), errors);
- require_non_empty_string(hop, &format!("{base}/at"), errors);
+ require_non_empty_string_at(hop, "/from", &format!("{base}/from"), errors);
+ require_non_empty_string_at(hop, "/to", &format!("{base}/to"), errors);
+ require_non_empty_string_at(hop, "/action", &format!("{base}/action"), errors);
+ require_non_empty_string_at(hop, "/at", &format!("{base}/at"), errors);
}
}
@@ -240,55 +298,79 @@ fn require_string_eq(
expected: &str,
errors: &mut Vec<G004ConformanceError>,
) {
- match get_path(root, path).and_then(Value::as_str) {
+ require_string_eq_at(root, path, path, expected, errors);
+}
+
+fn require_string_eq_at(
+ root: &Value,
+ pointer: &str,
+ error_path: &str,
+ expected: &str,
+ errors: &mut Vec<G004ConformanceError>,
+) {
+ match get_path(root, pointer).and_then(Value::as_str) {
Some(actual) if actual == expected => {}
Some(actual) => errors.push(G004ConformanceError::new(
- path,
+ error_path,
format!("expected '{expected}', got '{actual}'"),
)),
None => errors.push(G004ConformanceError::new(
- path,
+ error_path,
"required string field missing",
)),
}
}
-fn require_non_empty_string(root: &Value, path: &str, errors: &mut Vec<G004ConformanceError>) {
- match get_path(root, path).and_then(Value::as_str) {
+fn require_non_empty_string_at(
+ root: &Value,
+ pointer: &str,
+ error_path: &str,
+ errors: &mut Vec<G004ConformanceError>,
+) {
+ match get_path(root, pointer).and_then(Value::as_str) {
Some(value) if !value.trim().is_empty() => {}
- Some(_) => errors.push(G004ConformanceError::new(path, "string must not be empty")),
+ Some(_) => errors.push(G004ConformanceError::new(
+ error_path,
+ "string must not be empty",
+ )),
None => errors.push(G004ConformanceError::new(
- path,
+ error_path,
"required string field missing",
)),
}
}
-fn require_one_of(
+fn require_one_of_at(
root: &Value,
- path: &str,
+ pointer: &str,
+ error_path: &str,
allowed: &[&str],
errors: &mut Vec<G004ConformanceError>,
) {
- match get_path(root, path).and_then(Value::as_str) {
+ match get_path(root, pointer).and_then(Value::as_str) {
Some(value) if allowed.contains(&value) => {}
Some(value) => errors.push(G004ConformanceError::new(
- path,
+ error_path,
format!("'{value}' is not one of {}", allowed.join(", ")),
)),
None => errors.push(G004ConformanceError::new(
- path,
+ error_path,
"required string field missing",
)),
}
}
-fn require_bool_true(root: &Value, path: &str, errors: &mut Vec<G004ConformanceError>) {
- match get_path(root, path).and_then(Value::as_bool) {
+fn require_bool_true_at(
+ root: &Value,
+ pointer: &str,
+ error_path: &str,
+ errors: &mut Vec<G004ConformanceError>,
+) {
+ match get_path(root, pointer).and_then(Value::as_bool) {
Some(true) => {}
- Some(false) => errors.push(G004ConformanceError::new(path, "must be true")),
+ Some(false) => errors.push(G004ConformanceError::new(error_path, "must be true")),
None => errors.push(G004ConformanceError::new(
- path,
+ error_path,
"required boolean field missing",
)),
}