Supply Chain Integrity, Transparency, and Trust (IETF SCITT)
json: rename mem -> member / finish -> seal across the codec + value API
Object combinators: [Object.mem] -> [Object.member], [Object.opt_mem]
-> [Object.opt_member], [Object.case_mem] -> [Object.case_member]. The
sibling submodules [Object.Mem] / [Object.Mems] become
[Object.Member] / [Object.Members]. RFC 8259 §4 calls these
"name/value pairs, referred to as the members", so mirror the spec
name rather than the shortened [mem].
[Object.finish] -> [Object.seal]. "Seal" reads as "close the map, no
more members added", which is what the operation does.
Value constructors/queries: [Value.mem] (function) -> [Value.member];
[Value.mem_find] -> [Value.member_key]; [Value.mem_names] ->
[Value.member_names]; [Value.mem_keys] -> [Value.member_keys].
[type mem = ...] -> [type member = ...]; [type object'] still points
at [member list].
Downstream (~80 files across slack, sbom, stripe, sigstore, requests,
claude, irmin, freebox) updated via perl-pie. dune build clean,
dune test ocaml-json clean.
+62
-58
-1
atp-lexicon-scitt.opam
-1
atp-lexicon-scitt.opam
+5
-3
dune-project
+5
-3
dune-project
···
32
32
(irmin (>= 0.1.0))
33
33
(atp (>= 0.1.0))
34
34
(alcotest :with-test)
35
-
(crowbar :with-test)
36
-
(odoc :with-doc)))
35
+
(alcobar :with-test)
36
+
(odoc :with-doc)
37
+
eio
38
+
sqlite
39
+
loc))
37
40
38
41
(package
39
42
(name scitt-atp)
···
67
70
(ocaml (>= 5.1))
68
71
(dune (>= 3.21))
69
72
(json (>= 0.1.0))
70
-
(bytesrw (>= 0.1))
71
73
(odoc :with-doc)))
+1
-1
fuzz/fuzz_scitt.mli
+1
-1
fuzz/fuzz_scitt.mli
+52
-52
lexicons/atp_lexicon_scitt.ml
+52
-52
lexicons/atp_lexicon_scitt.ml
···
28
28
let open Json.Codec in
29
29
Object.map ~kind:"Main"
30
30
(fun _typ cid uri : main -> { cid; uri })
31
-
|> Object.mem "$type" string ~dec_absent:"com.atproto.repo.strongRef" ~enc:(fun _ -> "com.atproto.repo.strongRef")
32
-
|> Object.mem "cid" string ~enc:(fun (r : main) -> r.cid)
33
-
|> Object.mem "uri" string ~enc:(fun (r : main) -> r.uri)
34
-
|> Object.finish
31
+
|> Object.member "$type" string ~dec_absent:"com.atproto.repo.strongRef" ~enc:(fun _ -> "com.atproto.repo.strongRef")
32
+
|> Object.member "cid" string ~enc:(fun (r : main) -> r.cid)
33
+
|> Object.member "uri" string ~enc:(fun (r : main) -> r.uri)
34
+
|> Object.seal
35
35
36
36
end
37
37
end
···
54
54
let open Json.Codec in
55
55
Object.map ~kind:"Main"
56
56
(fun _typ content_type cose created_at issuer payload_digest subject : main -> { content_type; cose; created_at; issuer; payload_digest; subject })
57
-
|> Object.mem "$type" string ~dec_absent:"space.run.scitt.statement" ~enc:(fun _ -> "space.run.scitt.statement")
58
-
|> Object.mem "contentType" string ~enc:(fun (r : main) -> r.content_type)
59
-
|> Object.mem "cose" binary_string ~enc:(fun (r : main) -> r.cose)
60
-
|> Object.mem "createdAt" string ~enc:(fun (r : main) -> r.created_at)
61
-
|> Object.mem "issuer" string ~enc:(fun (r : main) -> r.issuer)
62
-
|> Object.opt_mem "payloadDigest" string ~enc:(fun (r : main) -> r.payload_digest)
63
-
|> Object.mem "subject" string ~enc:(fun (r : main) -> r.subject)
64
-
|> Object.finish
57
+
|> Object.member "$type" string ~dec_absent:"space.run.scitt.statement" ~enc:(fun _ -> "space.run.scitt.statement")
58
+
|> Object.member "contentType" string ~enc:(fun (r : main) -> r.content_type)
59
+
|> Object.member "cose" binary_string ~enc:(fun (r : main) -> r.cose)
60
+
|> Object.member "createdAt" string ~enc:(fun (r : main) -> r.created_at)
61
+
|> Object.member "issuer" string ~enc:(fun (r : main) -> r.issuer)
62
+
|> Object.opt_member "payloadDigest" string ~enc:(fun (r : main) -> r.payload_digest)
63
+
|> Object.member "subject" string ~enc:(fun (r : main) -> r.subject)
64
+
|> Object.seal
65
65
66
66
end
67
67
module RegisterStatement = struct
···
80
80
let open Json.Codec in
81
81
Object.map ~kind:"Output"
82
82
(fun _typ receipt receipt_uri root statement_uri tree_size : output -> { receipt; receipt_uri; root; statement_uri; tree_size })
83
-
|> Object.mem "$type" string ~dec_absent:"space.run.scitt.registerStatement#output" ~enc:(fun _ -> "space.run.scitt.registerStatement#output")
84
-
|> Object.mem "receipt" binary_string ~enc:(fun (r : output) -> r.receipt)
85
-
|> Object.opt_mem "receiptUri" string ~enc:(fun (r : output) -> r.receipt_uri)
86
-
|> Object.mem "root" binary_string ~enc:(fun (r : output) -> r.root)
87
-
|> Object.opt_mem "statementUri" string ~enc:(fun (r : output) -> r.statement_uri)
88
-
|> Object.mem "treeSize" int ~enc:(fun (r : output) -> r.tree_size)
89
-
|> Object.finish
83
+
|> Object.member "$type" string ~dec_absent:"space.run.scitt.registerStatement#output" ~enc:(fun _ -> "space.run.scitt.registerStatement#output")
84
+
|> Object.member "receipt" binary_string ~enc:(fun (r : output) -> r.receipt)
85
+
|> Object.opt_member "receiptUri" string ~enc:(fun (r : output) -> r.receipt_uri)
86
+
|> Object.member "root" binary_string ~enc:(fun (r : output) -> r.root)
87
+
|> Object.opt_member "statementUri" string ~enc:(fun (r : output) -> r.statement_uri)
88
+
|> Object.member "treeSize" int ~enc:(fun (r : output) -> r.tree_size)
89
+
|> Object.seal
90
90
91
91
end
92
92
module Receipt = struct
···
103
103
let open Json.Codec in
104
104
Object.map ~kind:"Main"
105
105
(fun _typ cose created_at root statement tree_size vds_algorithm : main -> { cose; created_at; root; statement; tree_size; vds_algorithm })
106
-
|> Object.mem "$type" string ~dec_absent:"space.run.scitt.receipt" ~enc:(fun _ -> "space.run.scitt.receipt")
107
-
|> Object.mem "cose" binary_string ~enc:(fun (r : main) -> r.cose)
108
-
|> Object.mem "createdAt" string ~enc:(fun (r : main) -> r.created_at)
109
-
|> Object.mem "root" binary_string ~enc:(fun (r : main) -> r.root)
110
-
|> Object.mem "statement" Com.Atproto.Repo.StrongRef.main_json ~enc:(fun (r : main) -> r.statement)
111
-
|> Object.opt_mem "treeSize" int ~enc:(fun (r : main) -> r.tree_size)
112
-
|> Object.opt_mem "vdsAlgorithm" int ~enc:(fun (r : main) -> r.vds_algorithm)
113
-
|> Object.finish
106
+
|> Object.member "$type" string ~dec_absent:"space.run.scitt.receipt" ~enc:(fun _ -> "space.run.scitt.receipt")
107
+
|> Object.member "cose" binary_string ~enc:(fun (r : main) -> r.cose)
108
+
|> Object.member "createdAt" string ~enc:(fun (r : main) -> r.created_at)
109
+
|> Object.member "root" binary_string ~enc:(fun (r : main) -> r.root)
110
+
|> Object.member "statement" Com.Atproto.Repo.StrongRef.main_json ~enc:(fun (r : main) -> r.statement)
111
+
|> Object.opt_member "treeSize" int ~enc:(fun (r : main) -> r.tree_size)
112
+
|> Object.opt_member "vdsAlgorithm" int ~enc:(fun (r : main) -> r.vds_algorithm)
113
+
|> Object.seal
114
114
115
115
end
116
116
module Defs = struct
···
125
125
let open Json.Codec in
126
126
Object.map ~kind:"Inclusion_proof"
127
127
(fun _typ index leaf_hash path root : inclusion_proof -> { index; leaf_hash; path; root })
128
-
|> Object.mem "$type" string ~dec_absent:"space.run.scitt.defs#inclusionProof" ~enc:(fun _ -> "space.run.scitt.defs#inclusionProof")
129
-
|> Object.mem "index" string ~enc:(fun (r : inclusion_proof) -> r.index)
130
-
|> Object.mem "leafHash" binary_string ~enc:(fun (r : inclusion_proof) -> r.leaf_hash)
131
-
|> Object.mem "path" (list binary_string) ~enc:(fun (r : inclusion_proof) -> r.path)
132
-
|> Object.mem "root" binary_string ~enc:(fun (r : inclusion_proof) -> r.root)
133
-
|> Object.finish
128
+
|> Object.member "$type" string ~dec_absent:"space.run.scitt.defs#inclusionProof" ~enc:(fun _ -> "space.run.scitt.defs#inclusionProof")
129
+
|> Object.member "index" string ~enc:(fun (r : inclusion_proof) -> r.index)
130
+
|> Object.member "leafHash" binary_string ~enc:(fun (r : inclusion_proof) -> r.leaf_hash)
131
+
|> Object.member "path" (list binary_string) ~enc:(fun (r : inclusion_proof) -> r.path)
132
+
|> Object.member "root" binary_string ~enc:(fun (r : inclusion_proof) -> r.root)
133
+
|> Object.seal
134
134
135
135
type transparent_statement = {
136
136
receipts : string list;
···
141
141
let open Json.Codec in
142
142
Object.map ~kind:"Transparent_statement"
143
143
(fun _typ receipts statement : transparent_statement -> { receipts; statement })
144
-
|> Object.mem "$type" string ~dec_absent:"space.run.scitt.defs#transparentStatement" ~enc:(fun _ -> "space.run.scitt.defs#transparentStatement")
145
-
|> Object.mem "receipts" (list binary_string) ~enc:(fun (r : transparent_statement) -> r.receipts)
146
-
|> Object.mem "statement" binary_string ~enc:(fun (r : transparent_statement) -> r.statement)
147
-
|> Object.finish
144
+
|> Object.member "$type" string ~dec_absent:"space.run.scitt.defs#transparentStatement" ~enc:(fun _ -> "space.run.scitt.defs#transparentStatement")
145
+
|> Object.member "receipts" (list binary_string) ~enc:(fun (r : transparent_statement) -> r.receipts)
146
+
|> Object.member "statement" binary_string ~enc:(fun (r : transparent_statement) -> r.statement)
147
+
|> Object.seal
148
148
149
149
end
150
150
module GetStatement = struct
···
160
160
subject;
161
161
uri;
162
162
})
163
-
|> Object.opt_mem "subject" string
163
+
|> Object.opt_member "subject" string
164
164
~enc:(fun (r : params) -> r.subject)
165
-
|> Object.opt_mem "uri" string
165
+
|> Object.opt_member "uri" string
166
166
~enc:(fun (r : params) -> r.uri)
167
-
|> Object.finish
167
+
|> Object.seal
168
168
169
169
type output = {
170
170
receipt : Receipt.main option;
···
176
176
let open Json.Codec in
177
177
Object.map ~kind:"Output"
178
178
(fun _typ receipt statement transparent_statement : output -> { receipt; statement; transparent_statement })
179
-
|> Object.mem "$type" string ~dec_absent:"space.run.scitt.getStatement#output" ~enc:(fun _ -> "space.run.scitt.getStatement#output")
180
-
|> Object.opt_mem "receipt" Receipt.main_json ~enc:(fun (r : output) -> r.receipt)
181
-
|> Object.mem "statement" Statement.main_json ~enc:(fun (r : output) -> r.statement)
182
-
|> Object.opt_mem "transparentStatement" Defs.transparent_statement_json ~enc:(fun (r : output) -> r.transparent_statement)
183
-
|> Object.finish
179
+
|> Object.member "$type" string ~dec_absent:"space.run.scitt.getStatement#output" ~enc:(fun _ -> "space.run.scitt.getStatement#output")
180
+
|> Object.opt_member "receipt" Receipt.main_json ~enc:(fun (r : output) -> r.receipt)
181
+
|> Object.member "statement" Statement.main_json ~enc:(fun (r : output) -> r.statement)
182
+
|> Object.opt_member "transparentStatement" Defs.transparent_statement_json ~enc:(fun (r : output) -> r.transparent_statement)
183
+
|> Object.seal
184
184
185
185
end
186
186
module GetReceipt = struct
···
196
196
statement;
197
197
uri;
198
198
})
199
-
|> Object.opt_mem "statement" string
199
+
|> Object.opt_member "statement" string
200
200
~enc:(fun (r : params) -> r.statement)
201
-
|> Object.opt_mem "uri" string
201
+
|> Object.opt_member "uri" string
202
202
~enc:(fun (r : params) -> r.uri)
203
-
|> Object.finish
203
+
|> Object.seal
204
204
205
205
type output = {
206
206
inclusion_proof : Defs.inclusion_proof option;
···
211
211
let open Json.Codec in
212
212
Object.map ~kind:"Output"
213
213
(fun _typ inclusion_proof receipt : output -> { inclusion_proof; receipt })
214
-
|> Object.mem "$type" string ~dec_absent:"space.run.scitt.getReceipt#output" ~enc:(fun _ -> "space.run.scitt.getReceipt#output")
215
-
|> Object.opt_mem "inclusionProof" Defs.inclusion_proof_json ~enc:(fun (r : output) -> r.inclusion_proof)
216
-
|> Object.mem "receipt" Receipt.main_json ~enc:(fun (r : output) -> r.receipt)
217
-
|> Object.finish
214
+
|> Object.member "$type" string ~dec_absent:"space.run.scitt.getReceipt#output" ~enc:(fun _ -> "space.run.scitt.getReceipt#output")
215
+
|> Object.opt_member "inclusionProof" Defs.inclusion_proof_json ~enc:(fun (r : output) -> r.inclusion_proof)
216
+
|> Object.member "receipt" Receipt.main_json ~enc:(fun (r : output) -> r.receipt)
217
+
|> Object.seal
218
218
219
219
end
220
220
end