| Internet-Draft | Dual-Receipt Profile | November 2026 |
| Jones | Expires 17 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 17 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 evaluation was registered after the decision.¶
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.¶
A synthetic reference implementation, OIGP version 1.3.6, implements this profile and 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. Version 1.3.6 has not been deposited at the time of writing. 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 MUST also satisfy the encoding profile in Section 5.1.¶
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 that a verifier needs enough of them to recompute the rules it recomputes (Section 6.6).¶
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 and MUST NOT affect the result of verification.¶
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, so a change of policy is visible to every verifier.¶
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.¶
B3 is implied by B2 when Receipt A verifies, because the leaf hash of Statement A covers its signature. B3 is kept because it binds the evaluation to the exact signature without the Receipt, 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. It performs the following steps in order and stops with failure at the first step that fails.¶
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, and a completeness value. 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: rule B6 shows that the evaluation was registered after the decision in the same log. That shows 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. In the reference implementation these are 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). The remaining rules, 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. For those rules the outcome is the Validator's assertion, and a verifier MUST report them as asserted and not as verified. 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 nothing else. No line 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. Entries 0 and 1 are not reproduced in this appendix, so a reader can check every value above but cannot repeat the completeness check from this document alone.¶