| Internet-Draft | Dual-Receipt Profile | November 2026 |
| Jones | Expires 24 May 2027 | [Page] |
This document specifies a dual-receipt profile for recording one disbursement decision as two signed statements, made by two different parties and registered with the same Transparency Service. An approver acting for a fiscal sponsor signs a Decision Statement. A validator acting for a receiving institution signs a Policy Evaluation Statement that binds to the Decision Statement's identifier, receipt, and signature, and records the outcome of a named policy. The profile defines the JSON members of both statements, a canonical encoding based on the JSON Canonicalization Scheme, SHA-256 statement identifiers, a composite identifier, Merkle tree receipts that use the hashing rules of RFC 9162, and a verification procedure. It also states the limits of the evidence: a bundle of statements cannot show that no conflicting evaluation exists, and the times inside the statements are claims made by their signers.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 24 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
In fiscal sponsorship, a sponsoring organization holds and disburses funds on behalf of a project. Each disbursement involves at least two questions that are answered by different parties: who decided to release the funds, and whether that decision satisfied the policy that another party, such as a funder or a receiving institution, applies to it.¶
A single signed statement cannot answer both questions. Its signature shows which key signed the payload. If the same signer also asserts that the decision satisfied a policy, that assertion is still made by the decision maker, so it is self-attested. Adding a policy result to the decision payload does not change who signed it.¶
This document therefore uses two statements. The approver signs a Decision Statement. A validator, holding a different key, verifies the Decision Statement and its receipt, evaluates it against a named policy, and signs a Policy Evaluation Statement that commits to the exact Decision Statement, its receipt, and its signature. Both statements are registered with the same Transparency Service, and each receives its own Receipt. A verifier who holds both statements and both Receipts can check who decided, which policy was applied by whom, and that the Receipt for the evaluation claims a later leaf position than the Receipt for the decision under one Transparency Service key. Section 6.3 states what that does and does not show.¶
This document defines a JSON profile. It does not use COSE, and the Receipt defined in Section 4.6 is not a COSE Receipt as defined in [RFC9942]. This document borrows terminology from [RFC9943] but does not claim conformance to [RFC9943], to [RFC9942], or to any Internet-Draft cited in this document.¶
Statement identification and relationships between statements are open discussion topics. [I-D.gruszka-scitt-statement-identification] describes requirements and test cases for identifying signed statements and does not select an identification scheme. [I-D.nobuo-scitt-composite-evidence-verification] describes composite verification of statement graphs. Both are individual drafts. The identifier choices in this document are specific to this profile and are not offered as answers to those discussions.¶
This document does not define how keys are issued to approvers and validators, how a Transparency Service authenticates issuers, how tree heads are distributed or checked for consistency, or what any particular disbursement policy contains. It makes no statement about tax, accounting, or grant law. Fiscal sponsorship is the motivating case; the mechanism does not depend on it.¶
The synthetic OIGP version 1.3.6 reference bundle produced the test vectors in Appendix A. It uses synthetic organizations, synthetic identifiers, and test keys derived from public labels. The vectors were re-derived by a separate script that uses only a SHA-256 library and an Ed25519 library, and shares no code with the reference implementation.¶
An earlier version of the same software (OIGP 1.3.1-hardened) is archived under DOI 10.5281/zenodo.24177899. That version predates the dual-receipt profile and does not contain it. This document provides no archival identifier for the 1.3.6 bundle. The reference verifier pins a registration-policy digest by default, can be run with none, and checks a supplied composite_id at step 9, in the order of Section 5.7. The DOI is cited for illustration only. It is not an independent audit, review, or certification of this profile or of any implementation.¶
The reference implementation also carries a legacy field named "d2" in its internal decision record, computed as SHA-256 over the hexadecimal D1 followed by the decision time. That field is not part of this profile and is unrelated to D2 as defined in Section 2.¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
The following notation is used. H(x) is SHA-256 [RFC6234] applied to the octet string x, producing 32 octets. "||" denotes concatenation of octet strings. hex(x) is the lowercase hexadecimal encoding of x, two characters per octet, using only the characters "0"-"9" and "a"-"f". unhex(s) is its inverse. canon(v) is the canonical encoding of the JSON value v defined in Section 5.1. A "64-hex string" is the hex() of 32 octets; a "128-hex string" is the hex() of 64 octets.¶
The protocol has three phases: decision, evaluation, and verification.¶
Approver Transparency Service Validator
| | |
|-- Statement A ---------->| (1) Decision |
|<-------- Receipt A ------| |
| | |
|-- Statement A + Receipt A --------------------------->|
| | (2) Evaluation |
| |<-------- Statement B ------|
| |------- Receipt B --------->|
| | |
Verifier: A, Receipt A, B, Receipt B
(3) Verification
The Approver builds a Decision Statement payload, signs canon(payload) with its Ed25519 key, and submits the signed statement to the Transparency Service. The Transparency Service checks the statement against its Registration Policy, appends it to the log, and returns Receipt A.¶
The Validator obtains Statement A and Receipt A. It verifies the Approver's signature and Receipt A. If either check fails, the Validator MUST NOT issue a Policy Evaluation Statement for those bytes. Otherwise it evaluates every rule of its policy, builds a Policy Evaluation Statement payload that binds to D1, to Receipt A, and to the Approver's signature, signs it with its own Ed25519 key, and registers it with the same Transparency Service. A failed rule produces a signed result of "REJECT"; a rejection is evidence in the same way as an acceptance. The Transparency Service returns Receipt B.¶
A verifier receives a Composite containing both statements and both Receipts. It checks both signatures, both Receipts, every binding defined in Section 5.5, and the consistency of the overall result with the per-rule results, using the procedure in Section 5.7. With the Composite alone, the verifier can confirm that the evaluation exists. It cannot confirm that no other evaluation exists. For that it needs a Log View (Section 6.2).¶
This section defines every JSON object used by the profile. Each object MUST contain exactly the members listed for it, unless the object's definition states otherwise. A producer MUST NOT add members, and a verifier MUST reject an object with a missing member, an additional member, or a member whose value does not meet the stated constraint. All values of the members that an object's definition lists MUST also satisfy the encoding profile in Section 5.1. Members that Section 4.7 allows beyond the listed ones are outside that requirement.¶
Each object type has a fixed type value, carried in its typ member:¶
Decision Statement oigp.dual-receipt.decision.v1 Policy Evaluation Statement oigp.dual-receipt.policy-evaluation.v1 Signed Tree Head oigp.dual-receipt.sth.v1 Composite oigp.dual-receipt.composite.v1¶
timestamp = 4DIGIT "-" 2DIGIT "-" 2DIGIT "T"
2DIGIT ":" 2DIGIT ":" 2DIGIT "Z"
¶
The Decision Statement payload is a JSON object with exactly the following seven members.¶
| Member | Type | Constraint |
|---|---|---|
| typ | string | Decision Statement type value (Section 4.1) |
| iss | string | 64-hex; Key Identifier of the Approver's key |
| draw_no | integer | 1 to 2^53-1; request number within the pair |
| amount_cents | integer | 1 to 2^53-1; amount in cents |
| pair_key | string | 128-hex; identifies the sponsor-project pair |
| status | string | "APPROVED" or "DENIED" |
| decided_at | string | Timestamp of the decision |
This profile does not carry a currency code. The currency of amount_cents is fixed by the sponsorship agreement and is outside the scope of this document. The pair_key is an opaque identifier; see Section 6.7 for how it should be derived.¶
The Policy Evaluation Statement payload is a JSON object with exactly the following ten members.¶
| Member | Type | Constraint |
|---|---|---|
| typ | string | Policy Evaluation Statement type value (Section 4.1) |
| iss | string | 64-hex; Key Identifier of the Validator's key |
| binds_to_statement_id | string | 64-hex; D1 |
| binds_to_receipt_sha256 | string | 64-hex; hex(H(canon(Receipt A))) |
| binds_to_signature_sha256 | string | 64-hex; hex(H(raw 64-octet signature of Statement A)) |
| policy_id | string | non-empty; names the policy |
| policy_sha256 | string | 64-hex; hex(H(canon(policy document))) |
| rule_results | array | non-empty; see below |
| result | string | "ACCEPT" or "REJECT" |
| evaluated_at | string | Timestamp of the evaluation |
Each element of rule_results is an array of exactly two strings: a non-empty rule identifier followed by "PASS" or "FAIL". Rule identifiers MUST be unique within the array. The order of elements is significant, because it is part of the signed bytes; the identifiers MUST equal, in the same order, the rules array of the policy document that policy_sha256 names. A verifier rejects a statement that omits a rule, adds a rule, repeats a rule, or reorders the rules.¶
The value of result MUST be "ACCEPT" if and only if every element of rule_results has the outcome "PASS". Otherwise it MUST be "REJECT". The value of evaluated_at MUST NOT be earlier than the decided_at of the bound Decision Statement.¶
The policy document is a JSON object that satisfies Section 5.1. It MUST contain a member policy_id (a non-empty string of at most 64 characters) and a member rules (a non-empty array of unique, non-empty rule identifiers). Other members are defined by the Validator and are outside the scope of this document, except the members that the rules a verifier recomputes read (Section 6.6), which step 2 of Section 5.7 lists with their types and formats.¶
Each statement is transported as a JSON object with exactly three members:¶
The statement_id member is a convenience copy. It is not signed. A verifier MUST recompute it from the payload and MUST reject the statement if the values differ.¶
A Signed Tree Head is a JSON object with exactly five members:¶
The Transparency Service signs canon(sth) with its Ed25519 key. The resulting signature is carried as the 128-hex string sth_sig. A Signed Tree Head in this profile contains no time value.¶
A Receipt is a JSON object with exactly five members:¶
Every member of a Receipt is ASCII text. A Receipt MUST NOT carry additional members, such as labels or markers, because binds_to_receipt_sha256 is computed over the whole Receipt.¶
A Composite is a JSON object that MUST contain the following members:¶
A producer SHOULD include a member composite_id whose value is the Composite Identifier (Section 5.6) as a 64-hex string. The Composite is not signed as a whole; its integrity comes from the signatures and Receipts it contains. Other members MAY be present. They are not covered by any signature, are not subject to the encoding profile in Section 5.1, and MUST NOT affect the result of verification. The requirement in Section 5.1 that a parser reject duplicate member names applies to the whole text, including these members.¶
The Transparency Service MUST register a statement only if all of the following hold. It MUST check all of them before changing any state, so that a refused statement leaves the log unchanged.¶
Rule 7 allows at most one evaluation of a given decision by a given Validator. Without it, a Validator could register a "REJECT" and later an "ACCEPT" for the same decision, and a holder could present only the "ACCEPT". Rule 4 allows at most one decision for a given draw by a given Approver. Without it, an Approver could register a "DENIED" decision and a later "APPROVED" decision for the same draw, each with its own valid evaluation. Rule 2 stops an Approver key from issuing evaluations and a Validator key from issuing decisions. The Registration Policy is itself a JSON value, and its digest is carried in every Signed Tree Head. A change of policy is therefore visible to a verifier that compares that digest with one it holds, as steps 4 and 6 of Section 5.7 require when it holds one.¶
canon(v) is the JSON Canonicalization Scheme (JCS) encoding [RFC8785] of the value v, as UTF-8 octets. To remove the parts of JCS that commonly differ between implementations, this profile restricts every value that is signed, hashed, or placed in a Receipt to the following:¶
The literal null, numbers with a fraction or exponent, integers outside the range above, and any character outside U+0020 to U+007E MUST be rejected. A boolean MUST NOT be accepted where an integer is required. A parser MUST reject an object with duplicate member names, as required by I-JSON (Section 2.3 of [RFC7493]), on which JCS relies.¶
Under this restriction, canon(v) is the JSON text [RFC8259] of v with object members sorted by name in ascending order of their octets, no whitespace between tokens, the characters quotation mark and reverse solidus in strings written as \" and \\, and every other character written as itself. The restriction makes this simplified description and JCS produce the same octets: for ASCII names, sorting by UTF-16 code units (Section 3.2.3 of [RFC8785]) equals sorting by octets; no control character can occur, so no other escape is produced (Section 3.2.2.2 of [RFC8785]); and every integer in range is represented exactly by an IEEE 754 double, so its JCS serialization is its plain decimal form (Section 3.2.2.3 of [RFC8785]).¶
D1 = H(canon(payload_A)) (32 octets) D2 = H(canon(payload_B)) (32 octets)¶
Statement Identifiers are carried as 64-hex strings, for example in statement_id and binds_to_statement_id. The digest covers the payload only. It does not cover the signature; the signature is bound separately (Section 5.5).¶
The exact signed statement has its own digest, the Signed Statement Digest:¶
SSD = H(canon({"payload": payload, "sig": sig})) (32 octets)
¶
The SSD changes if either the payload or the signature changes. The Statement Identifier changes only if the payload changes. The Merkle leaf hash of a statement (Section 5.4) is H(0x00 || the same canonical octets), so the SSD and the leaf hash are different values computed over the same input octets. The SSD is not a member of any statement and is not carried in the Composite; a party that needs it computes it. A verifier that outputs it uses it only as a name for the signed statement, never as input to a check.¶
All signatures are Ed25519 as specified in Section 5.1 of [RFC8032], without prehashing and without context. The message signed is the octet string canon(payload) for a statement, and canon(sth) for a Signed Tree Head. A signature is 64 octets and is carried as a 128-hex string.¶
A verifier MUST verify signatures as specified in Section 5.1.7 of [RFC8032]. In particular it MUST reject a signature whose scalar S is not less than the group order L, so that a signature cannot be altered into a second valid encoding. A verifier MUST reject a sig, sth_sig, or audit_path value that contains uppercase hexadecimal characters.¶
The Approver's key and the Validator's key MUST be different. A verifier MUST reject a Composite in which the two public keys it uses for Statement A and Statement B are equal.¶
The log entry for a signed statement is the octet string¶
leaf_data = canon({"payload": payload, "sig": sig})
¶
so the log commits to both the payload and the signature. Hashing follows Section 2.1.1 of [RFC9162]:¶
leaf hash = H(0x00 || leaf_data) node hash = H(0x01 || left || right)¶
The root in a Signed Tree Head is the Merkle Tree Hash over all entries in log order, as defined in Section 2.1.1 of [RFC9162]. A verifier checks a Receipt by running the algorithm of Section 2.1.3.2 of [RFC9162] with leaf_index, tree_size, the leaf hash, audit_path (each element decoded with unhex), and root. A verifier MUST reject the Receipt if leaf_index is not less than tree_size, if any decoded value is not 32 octets, or if the algorithm fails.¶
Let A and B be the Decision Statement and the Policy Evaluation Statement, RA and RB their Receipts, and p the payload of B. A Composite is valid only if all of the following hold.¶
B2 and B3 are independent, and both are required. B2 compares a member of the evaluation payload with the digest of Receipt A. B3 compares a different member with the digest of the raw signature of Statement A. A Receipt that verifies does not determine the value that the Validator wrote in the second member, so a payload can satisfy B2 and fail B3. B3 binds the evaluation to the exact signature, which is what the Transparency Service checks under Registration Policy rule 6 (Section 4.8).¶
CID = H(D1 || D2) (input: 64 octets; output: 32 octets)¶
D1 and D2 are the 32-octet digests, not their hexadecimal text. Hashing the 128-character hexadecimal text instead produces a different value; Appendix A shows both. The order is fixed: H(D2 || D1) is a different value and MUST NOT be used.¶
The Composite Identifier covers Receipt A indirectly, because the payload of B contains binds_to_receipt_sha256. It does not cover Receipt B. Registration Policy rule 7 prevents an honest Transparency Service from registering the same Policy Evaluation Statement twice, but a Transparency Service that did not enforce it could issue two different Receipt B values for statements with the same Composite Identifier. The Composite Identifier is therefore a name for a pair of statements, not evidence that the pair is valid.¶
A verifier is given a Composite, the Approver's public key, the Validator's public key, the Transparency Service's public key, the policy document, and optionally a Log View and a locally configured expected Registration Policy digest. It performs the following steps in order and stops with failure at the first step that fails.¶
Before step 1 the verifier parses the Composite text as JSON. Malformed JSON, invalid UTF-8, a byte order mark, and a duplicate member name at any depth, including inside members that are otherwise ignored (Section 5.1), fail at this parse stage, which is reported as step 0. The encoding profile of Section 5.1 is applied to each object in the step that checks that object: the policy document in step 2, Statement A in step 3, Receipt A in step 4, Statement B in step 5, Receipt B in step 6, and composite_id in step 9. Step 1 does not apply it.¶
On success, the verifier outputs hex(D1), hex(D2), hex(CID), the Signed Statement Digest of each statement, the result ("ACCEPT" or "REJECT", as stated by the Validator and checked by B5 and B10), the list of rules it recomputed, the list of rules that rest on the Validator's assertion alone, the sth.registration_policy_sha256 value of each Receipt, whether the two values are equal, whether they were compared with a digest the verifier holds, and a completeness value. If the verifier holds no expected digest, it MUST report the Registration Policy digest as not checked against an expectation; two Receipts whose values differ show that the Transparency Service reported different policies in the two tree heads, and a verifier MUST report that difference. A successful verification of a Composite whose result is "REJECT" is a verified rejection: the evidence is valid, and the Validator did not accept the decision.¶
The profile requires two different keys (B8). Two different keys do not prove two different organizations: one organization can hold both keys. The value of the second statement depends on the Validator being independent of the Approver, and that independence is established by how keys are issued and registered, which is outside the scope of this document. A verifier SHOULD obtain the Approver's and the Validator's public keys from separate, authenticated sources.¶
Registration Policy rule 2 (Section 4.8) makes the Transparency Service enforce the roles: a key registered as an Approver cannot register an evaluation, and a key registered as a Validator cannot register a decision. A verifier cannot observe that enforcement directly; it can only observe its effects through a Log View (Section 6.2).¶
If the Approver and the Validator collude, both statements can be valid and still misrepresent what happened. This profile makes such a record attributable to both keys; it does not prevent it.¶
The Validator MUST NOT issue a Policy Evaluation Statement over a Decision Statement whose signature or Receipt it has not verified (Section 3.2). Otherwise the Validator's signature would attest to bytes it never checked.¶
A Composite proves that two statements exist and are registered. It cannot prove that no other statement exists. In particular, if a Validator registered two evaluations of the same decision, one with result "REJECT" and one with result "ACCEPT", a holder could present only the "ACCEPT". Registration Policy rules 4 and 7 (Section 4.8) prevent this at an honest Transparency Service. A verifier who has only the Composite MUST report completeness as unknown, and MUST NOT report that the evaluation is the only one. This is consistent with the approach described in [I-D.nobuo-scitt-composite-evidence-verification], which recommends reporting unknown or a warning rather than a pass when completeness cannot be checked.¶
A verifier that obtains a Log View can check completeness. The Log View is authenticated only by the Transparency Service's signature on its tree head and by the recomputed root; the verifier does not learn from it whether the Transparency Service showed the same log to other parties. A Log View is a JSON object with members entries (the list of all log entries in order, each an object with members payload, sig, and statement_id), sth, and sth_sig. The verifier:¶
If all checks pass, the verifier reports completeness as checked for that Log View. This check is only as strong as the Log View. A Transparency Service that shows different logs to different parties (a split view) is not detected by it. Detecting a split view requires consistency proofs between tree heads and a way for parties to compare the tree heads they have seen. Both are outside the scope of this document.¶
The values decided_at and evaluated_at are claims made by the Approver and the Validator, inside payloads that they sign. They are not trusted time. Rule B7 checks only that the two claims are consistent with each other. The Signed Tree Head in this profile carries no time.¶
The only ordering evidence that does not depend on the signers is leaf position, and rule B6 uses it only weakly: B6 shows that, under one Transparency Service key, the leaf position claimed in Receipt B is larger than the one claimed in Receipt A. It does not show that the two tree heads describe the same append-only history, so it does not show that the evaluation was registered after the decision in one log. Establishing that requires evidence connecting those heads to a consistent history. An authenticated Log View is evidence about its own head unless the verifier also verifies the relevant relationship to both Receipt heads. Even then the result is order, not time. A deployment that needs evidence of when a statement existed needs an independent time source, such as a trusted timestamp over the statement or the tree head. That is outside the scope of this document.¶
Signatures and identifiers are computed over canon(v), not over the bytes that were received. Two implementations that canonicalize the same value differently will disagree on every signature and identifier. The restrictions in Section 5.1 remove the known sources of disagreement: non-ASCII text, control characters, floating-point numbers, large integers, and duplicate member names. An implementation MUST reject values outside the restrictions rather than attempt to normalize them.¶
Hexadecimal strings are compared as strings. Requiring lowercase removes a second representation of the same octets.¶
This profile defines no key revocation or rotation mechanism. A compromised Approver or Validator key can produce valid statements until the Transparency Service stops accepting it. This profile defines a single algorithm, Ed25519. A future profile with other algorithms would use different typ values.¶
The test keys in Appendix A are derived from public labels. They provide no security and MUST NOT be used outside testing.¶
A verifier can recompute only the rules whose inputs are in the Composite and the policy document. This profile requires the verifier to recompute the following five rules, whatever additional rules the policy lists: R1_DECISION_SIGNATURE_VALID, R2_DECISION_RECEIPT_VALID, R3_PAIR_KEY_MATCH, R4_STATUS_APPROVED, and R6_DECIDED_WITHIN_WINDOW. The verifier MUST recompute each of them and reject the Composite if a signed outcome differs (B10). Rules such as R5_AMOUNT_WITHIN_REMAINING_CAP and R7_DRAW_NOT_SEEN_BEFORE depend on the Validator's history of earlier evaluations, which a verifier cannot check from one Composite. The recomputed rules are defined as follows, where policy is the policy document the verifier holds, A is the Decision Statement payload, and Timestamps are compared as in Section 4.1:¶
For each rule identifier in rule_results other than the five recomputed identifiers, the outcome is the Validator's assertion. This includes R5 and R7 when the policy lists them, and any additional rule the policy lists. A verifier MUST report each such identifier as asserted and not as verified, in the order in which the identifiers occur in rule_results. Their signed outcomes take part in B5. The policy_sha256 member binds the evaluation to a specific policy document. It does not establish what that document means.¶
Everything in a registered payload is visible to anyone who can read the log, including amounts, request numbers, decision outcomes, times, and pair_key. Deployments SHOULD treat the log as public.¶
The pair_key links all statements about one sponsor-project pair. If pair_key is an unkeyed hash of a low-entropy value, such as a nine-digit tax identification number, it can be reversed by trying every possible value. A deployment that needs pair_key not to reveal the parties SHOULD derive it with a keyed function, such as HMAC with a key that is not published. The reference implementation uses an unkeyed derivation over synthetic identifiers and is not an example of how to protect real identifiers.¶
This document has no IANA actions.¶
This appendix is not normative. All values were produced by the reference implementation (Section 1.3) and checked with independent libraries. Long values are split across lines for display only: to recover a value, remove the line breaks and the indentation that the document format adds to every line (three spaces in the text form of this document, none in the XML source), and change nothing else. No line of a value itself begins or ends with a space.¶
Each Ed25519 private key seed is H of the ASCII label shown. These keys are for testing only.¶
Approver: label "SYN-SPONSOR-APPROVER"
seed
07dcf5901a847584c6d699876b832e9a276101e34dac0bcd4712afde1ffa36b2
public key
6c7a7dc5c82d38893fa89e4e3257eedf42286bbe5e477ea8db37df8b56654275
Key Identifier
d1b38349f2ad6bc1034aa1ef5e04dcb9d95f4747a3095510d7566812aad56480
Validator: label "SYN-VALIDATOR-RECEIVING-INSTITUTION"
seed
06c953ee14c1a18de9f02caa340d7309d573e91825555b778895dd862ea06992
public key
cb2ae047137b4b162510272f4d65369085d12502f5d894c4e4ca2fea92abd5e0
Key Identifier
bc82064d3506fe4003f1d7076221dab60be5fb300331d98d8d77a473c5527f27
Transparency Service: label "SYN-TRANSPARENCY-SERVICE"
seed
c90a51ec12752ed4f8df8ca654420a674af3fa03b63b34224006ce4593af8c72
public key
97cfbab282d8e7fd2fc23def8bed1370f286b9cd2214b9564bf2cb7a741dece0
Key Identifier
6be48ea80f7346b5e1d4c016afbd9257f14428848c3dea277a7034fe9824c2a2
¶
The log holds four entries. Entries 0 and 1 are an earlier decision (draw 1) and its evaluation. Entries 2 and 3 are the Decision Statement and the Policy Evaluation Statement shown below (draw 2). Receipt A was issued at tree size 3 and Receipt B at tree size 4.¶
Registration Policy, canonical form:¶
{"accepts":["oigp.dual-receipt.decision.v1","oigp.dual-receipt.p
olicy-evaluation.v1"],"id":"OIGP-TS-REG-4","requires":["payloa
d typ is one of the accepted type values","iss is a registered k
ey for the role the typ requires (decision: approver; policy_eva
luation: validator); approver and validator key sets are disjoin
t; sig is a valid Ed25519 signature by that key over canon(paylo
ad)","payload has exactly the members defined for its typ, wit
h the defined syntax; statement_id equals the recomputed Stateme
nt Identifier","decision: not already registered; at most one de
cision per (iss, pair_key, draw_no)","policy_evaluation: binds_t
o_statement_id is the Statement Identifier of a registered decis
ion","policy_evaluation: binds_to_signature_sha256 equals SHA-25
6 of that decision's raw 64-byte signature","policy_evaluation
: at most one per (binds_to_statement_id, iss)"]}
¶
registration_policy_sha256 fcd189e9f7b8f3857f8f7fd9011654ffefb7511c84ae816c2f13b89331e033d1¶
Validator policy document, canonical form:¶
{"approver_key_id":"d1b38349f2ad6bc1034aa1ef5e04dcb9d95f4747a309
5510d7566812aad56480","award_cap_cents":5000000,"expected_pair_k
ey":"94d4f37aec87057b2ec3a72529ec5e143619117d46c3a66ebeede4b8ffe
01dc1e6c58dcf4f4a8d896004b6dd0285223284ccae00d53eb5d1e2d35d3e583
8d4bb","policy_id":"OIGP-VAL-POLICY-1","rules":["R1_DECISION_SIG
NATURE_VALID","R2_DECISION_RECEIPT_VALID","R3_PAIR_KEY_MATCH","R
4_STATUS_APPROVED","R5_AMOUNT_WITHIN_REMAINING_CAP","R6_DECIDED_
WITHIN_WINDOW","R7_DRAW_NOT_SEEN_BEFORE"],"ts_key_id":"6be48ea80
f7346b5e1d4c016afbd9257f14428848c3dea277a7034fe9824c2a2","window
_end":"2026-12-31T23:59:59Z","window_start":"2026-11-01T00:00:00
Z"}
¶
policy_sha256 607162ca8978a96c2ae485007b98ac7b0c7c33500d88160bbd05b4c29e2c3604¶
canon(payload_A):¶
{"amount_cents":1000000,"decided_at":"2026-11-13T16:00:00Z","dra
w_no":2,"iss":"d1b38349f2ad6bc1034aa1ef5e04dcb9d95f4747a3095510d
7566812aad56480","pair_key":"94d4f37aec87057b2ec3a72529ec5e14361
9117d46c3a66ebeede4b8ffe01dc1e6c58dcf4f4a8d896004b6dd0285223284c
cae00d53eb5d1e2d35d3e5838d4bb","status":"APPROVED","typ":"oigp.d
ual-receipt.decision.v1"}
¶
D1 = H(canon(payload_A)) dfeb582c87775fbcc7fcc948d85fd6dda8a516329a7f40b3ecc8a97349c9a1fd¶
sig_A, Ed25519 over canon(payload_A) with the Approver's key:¶
3f9bae4e1596aec77c5ce3627a22ae692bd7cdcf73099356239dda27f901e019 65b7c1b4af0f32074fb4afb4e7083c398a6d22d598ffcdabc7bb7d09dc987a0c¶
SSD_A = H(canon({"payload": payload_A, "sig": sig_A}))
8b1a85865ee64127a810b6e3998551332242b3c17d2f943dc11f9f027c09ed22
leaf hash of entry 2
1c1f91e46a359b3bc0699d65f24dda045153047b21534eee61409a15fabd8d6e
¶
canon(Receipt A):¶
{"audit_path":["c0a4faa03f716e057b2f21871e1fb7beb165f7159e7f2a91
461dfba22ce19543"],"leaf_index":2,"statement_id":"dfeb582c87775f
bcc7fcc948d85fd6dda8a516329a7f40b3ecc8a97349c9a1fd","sth":{"regi
stration_policy_sha256":"fcd189e9f7b8f3857f8f7fd9011654ffefb7511
c84ae816c2f13b89331e033d1","root":"1a7a8c1940b945aa6b7b79467c097
afb226a59f5c2f53679397a7baece62b650","tree_size":3,"ts_key_id":"
6be48ea80f7346b5e1d4c016afbd9257f14428848c3dea277a7034fe9824c2a2
","typ":"oigp.dual-receipt.sth.v1"},"sth_sig":"66125a2a3ab6f5f94
ea12928070b233cf2c2c6489c98575f0e116bc960b78f235a403ec98bd516289
4918767ab91054a39edb3f40a495566952780617361be0b"}
¶
binds_to_receipt_sha256 = H(canon(Receipt A)) f1767607768d3dca872a47d35ba8e98585b6ae8b2c8e2a334bbd05831e1bebf7 binds_to_signature_sha256 = H(64 raw octets of sig_A) 9eaa4ae5549b8bd8075f03eb960ce4830dead0b9d1d59cdba57352a440bc0d36 for contrast only, H(128-character hex text of sig_A) 09d71800fff8bc8d3d1fd6dfd7509a8b3a325967060901f11ddc61f9d7a81da5¶
canon(payload_B):¶
{"binds_to_receipt_sha256":"f1767607768d3dca872a47d35ba8e98585b6
ae8b2c8e2a334bbd05831e1bebf7","binds_to_signature_sha256":"9eaa4
ae5549b8bd8075f03eb960ce4830dead0b9d1d59cdba57352a440bc0d36","bi
nds_to_statement_id":"dfeb582c87775fbcc7fcc948d85fd6dda8a516329a
7f40b3ecc8a97349c9a1fd","evaluated_at":"2026-11-13T16:05:00Z","i
ss":"bc82064d3506fe4003f1d7076221dab60be5fb300331d98d8d77a473c55
27f27","policy_id":"OIGP-VAL-POLICY-1","policy_sha256":"607162ca
8978a96c2ae485007b98ac7b0c7c33500d88160bbd05b4c29e2c3604","resul
t":"ACCEPT","rule_results":[["R1_DECISION_SIGNATURE_VALID","PASS
"],["R2_DECISION_RECEIPT_VALID","PASS"],["R3_PAIR_KEY_MATCH","PA
SS"],["R4_STATUS_APPROVED","PASS"],["R5_AMOUNT_WITHIN_REMAINING_
CAP","PASS"],["R6_DECIDED_WITHIN_WINDOW","PASS"],["R7_DRAW_NOT_S
EEN_BEFORE","PASS"]],"typ":"oigp.dual-receipt.policy-evaluation.
v1"}
¶
D2 = H(canon(payload_B)) c0f094c8ef3f6004ff50e96a0be39f15366496f62e009398d1537fe4cbb80316¶
sig_B, Ed25519 over canon(payload_B) with the Validator's key:¶
a9e4b1cd020566bfee6e11901a69b486b435f64a05a007c0380ad0fd6c247562 6705403c6793ceecb723d4015cfe7876ae25f18deca479bc9824b659f612b603¶
SSD_B = H(canon({"payload": payload_B, "sig": sig_B}))
8fff0fbcb3b77f8995bc38b95cb5e724264db03677e2b394a831795c62b4ff93
leaf hash of entry 3
98d398b545e375b62211dc9cbe993a6aad3d35966ad5c267ae9bcf1e1197057e
¶
canon(Receipt B):¶
{"audit_path":["1c1f91e46a359b3bc0699d65f24dda045153047b21534eee
61409a15fabd8d6e","c0a4faa03f716e057b2f21871e1fb7beb165f7159e7f2
a91461dfba22ce19543"],"leaf_index":3,"statement_id":"c0f094c8ef3
f6004ff50e96a0be39f15366496f62e009398d1537fe4cbb80316","sth":{"r
egistration_policy_sha256":"fcd189e9f7b8f3857f8f7fd9011654ffefb7
511c84ae816c2f13b89331e033d1","root":"bb844d9add6fb9c4357cc370af
02cad2d93307e1992ccd62bfd029261da371d6","tree_size":4,"ts_key_id
":"6be48ea80f7346b5e1d4c016afbd9257f14428848c3dea277a7034fe9824c
2a2","typ":"oigp.dual-receipt.sth.v1"},"sth_sig":"7548ac637a78b3
a152f842c0b6f5f331ce26921e9ed151b0d62062bb19f31ffc771d138d68c4eb
6a8beeb8c45043023b822049df98b3c069d8b6acddef8c4a00"}
¶
The audit path of Receipt B has two elements. The first is the leaf hash of entry 2; the second is the hash of the subtree over entries 0 and 1.¶
1c1f91e46a359b3bc0699d65f24dda045153047b21534eee61409a15fabd8d6e c0a4faa03f716e057b2f21871e1fb7beb165f7159e7f2a91461dfba22ce19543¶
root at tree size 3 (Receipt A) 1a7a8c1940b945aa6b7b79467c097afb226a59f5c2f53679397a7baece62b650 root at tree size 4 (Receipt B) bb844d9add6fb9c4357cc370af02cad2d93307e1992ccd62bfd029261da371d6¶
CID = H(D1 || D2), 64-octet input 364383c7d24a9f1902243cd206cfb35fe77b637ee38ffc5290861e3d4bbe38b8 for contrast only, H(128-character hex text of D1 then D2) f590a04993bbc2d009b2baec7c642b3f81abdcfd04c3e91eb474fe753d8a21f0¶
Given the Composite, the three public keys above, the policy document, and the full Log View, the reference verifier output result "ACCEPT" and completeness checked.¶
The two blocks below give the exact canonical leaf data for entries 0 and 1, respectively. Each block contains one value wrapped for display. Join its lines after removing display indentation. The leaves use the prefix and hashing rule in Section 5.4. The resulting subtree hash is the first and only proof element in Receipt A and the second proof element in Receipt B.¶
{"payload":{"amount_cents":400000,"decided_at":"2026-11-13T15:00:00Z
","draw_no":1,"iss":"d1b38349f2ad6bc1034aa1ef5e04dcb9d95f4747a309551
0d7566812aad56480","pair_key":"94d4f37aec87057b2ec3a72529ec5e1436191
17d46c3a66ebeede4b8ffe01dc1e6c58dcf4f4a8d896004b6dd0285223284ccae00d
53eb5d1e2d35d3e5838d4bb","status":"APPROVED","typ":"oigp.dual-receip
t.decision.v1"},"sig":"4c11fa6fce102b58026c9f72c23922fa40e44e7193846
fae474323e1c36dbbf5ff682e87c4366213aa6ca18f48613a88c7f1c4a024aa3433f
44cc54a7e991b03"}
¶
{"payload":{"binds_to_receipt_sha256":"eb0abc4b4104c84b6d6022234b376
4fcc13256ae1f19a4cfd3388ee72c56868f","binds_to_signature_sha256":"ff
a4d2cfa5d8be884063ae23fc99bde3e281c82d7e84d22de19abdcd960854f4","bin
ds_to_statement_id":"a5c9784e720840e972399360906fc778c5c6e7a5c13a07a
a3349441338a20c6d","evaluated_at":"2026-11-13T15:05:00Z","iss":"bc82
064d3506fe4003f1d7076221dab60be5fb300331d98d8d77a473c5527f27","polic
y_id":"OIGP-VAL-POLICY-1","policy_sha256":"607162ca8978a96c2ae485007
b98ac7b0c7c33500d88160bbd05b4c29e2c3604","result":"ACCEPT","rule_res
ults":[["R1_DECISION_SIGNATURE_VALID","PASS"],["R2_DECISION_RECEIPT_
VALID","PASS"],["R3_PAIR_KEY_MATCH","PASS"],["R4_STATUS_APPROVED","P
ASS"],["R5_AMOUNT_WITHIN_REMAINING_CAP","PASS"],["R6_DECIDED_WITHIN_
WINDOW","PASS"],["R7_DRAW_NOT_SEEN_BEFORE","PASS"]],"typ":"oigp.dual
-receipt.policy-evaluation.v1"},"sig":"c60547b307bac2fdeed27fe8892cb
922d12c2b0837f7c3ba6d331431bfa4b4c4e05f07c96cd19633c68e1695840c799b9
733b0202764ea90857f5b16f7ff1607"}
¶
The Receipt A tree head has tree size 3 and the Receipt B tree head has tree size 4. The consistency proof between them ([RFC9162], Section 2.1.4) has three elements, in this order: the leaf hash of entry 2, the leaf hash of entry 3, and the subtree hash of entries 0 and 1.¶
1c1f91e46a359b3bc0699d65f24dda045153047b21534eee61409a15fabd8d6e 98d398b545e375b62211dc9cbe993a6aad3d35966ad5c267ae9bcf1e1197057e c0a4faa03f716e057b2f21871e1fb7beb165f7159e7f2a91461dfba22ce19543¶
Verifying this proof with the algorithm in [RFC9162], Section 2.1.4.2 against the two signed roots succeeds. It is an example of the evidence that rule B6 does not require.¶
Konrad Gruszka independently implemented a verifier from the -00 text and reported differences that led to changes in -01 and -02. He also supplied review cases for -01.¶