Publish hardened v1.1.0 statement audit model

CITATION.cff

@@ -0,0 +1,18 @@
+cff-version: 1.2.0
+message: "If you use this audit model, cite it using the metadata below."
+title: "Lifted Payments Payment Statement Audit Model"
+type: dataset
+authors:
+  - name: "Lifted Payments"
+version: 1.1.0
+date-released: 2026-08-02
+doi: "10.5281/zenodo.21762273"
+url: "https://liftedpayments.com/payment-processing-statement-audit/"
+repository-code: "https://github.com/Lifted-Holdings/payment-processing-resources"
+license: CC-BY-4.0
+keywords:
+  - payment processing
+  - merchant services
+  - effective rate
+  - statement audit
+  - fintech

DATA_DICTIONARY.md

@@ -0,0 +1,41 @@
+# Payment statement audit data dictionary
+
+This dictionary defines v1.1.0 of the Lifted Payments Payment Statement Audit Model. Words such as “volume,” “fees,” and “transactions” are ambiguous across provider statements; the definitions below are part of the contract, not suggestions.
+
+## Record-level fields
+
+| Field | Type | Required | Definition |
+|---|---:|:---:|---|
+| `schema_version` | string | yes | Literal `1.1.0`. A different value requires a different schema and validator. |
+| `calculation_basis` | string | yes | Literal `gross_settled_purchase_volume_and_net_processing_fees`. It prevents unlike numerator and denominator conventions from being compared silently. |
+| `statement_period.start` | ISO date | yes | First calendar date represented by the statement, inclusive. |
+| `statement_period.end` | ISO date | yes | Last calendar date represented by the statement, inclusive. It must be on or after `start`; the inclusive period may not exceed 62 days. |
+| `currency` | string | yes | Literal `USD`. Do not convert or combine other currencies in a v1.1.0 record. |
+| `card_volume` | USD | yes | Gross dollar amount of settled purchase transactions in the period. Include the full settled purchase amount, including tax and tip when those are part of the capture. Exclude declines, authorization-only events, voids, refunds, chargebacks, cash advances, reserves, and funding adjustments. |
+| `transaction_count` | integer | yes | Number of settled purchase transactions included in `card_volume`. Exclude declines, authorization-only events, voids, refunds, and chargebacks. Volume and count must both be zero or both be positive. |
+| `gross_processing_fees` | USD | yes | Sum of the nine `fee_groups` before processing-fee credits. It includes only fees for accepting, authorizing, settling, supporting, or administering card processing. |
+| `statement_credits` | USD | yes | Processing-fee credits or rebates applied on the statement. Exclude customer refunds, chargeback principal, reserve releases, deposit adjustments, and other movement of merchant funds. |
+| `total_processing_fees` | USD | yes | Net fee numerator: `gross_processing_fees - statement_credits`. It cannot be negative in v1.1.0. |
+| `effective_rate` | decimal or null | yes | `total_processing_fees / card_volume`, rounded half up to six decimal places. Store `2.2918%` as `0.022918`. It must be `null` when `card_volume` is zero. |
+| `average_ticket` | USD or null | yes | `card_volume / transaction_count`, rounded half up to cents. It must be `null` when `transaction_count` is zero. |
+| `pricing_model` | enum | yes | How pricing is presented on the source statement: `interchange_plus`, `flat_rate`, `tiered`, `subscription`, `dual_pricing`, or `unknown`. This is not an interchange-qualification opinion. |
+| `fee_groups` | array | yes | One entry per used category. Categories are unique, amounts are gross nonnegative charges, and their exact cent sum equals `gross_processing_fees`. |
+| `review_notes` | string array | no | Short explanations of classification decisions. Never put merchant identity, card/account data, credentials, or secrets here. |
+
+All USD fields permit at most two decimal places. Rates permit at most six decimal places. Numbers must be finite. The validator imposes high operational ceilings to reject account-number-shaped or clearly implausible input; those ceilings are data-safety bounds, not merchant eligibility limits.
+
+## Fee-group taxonomy
+
+| Category | Include | Exclude or redirect |
+|---|---|---|
+| `interchange` | Issuer/interchange charges presented by the statement | Network assessments and provider markup |
+| `assessments` | Card-network assessment, access, and brand charges | Interchange and processor markup |
+| `processor_markup` | Provider percentage, basis-point, per-item, or service markup not assigned elsewhere | Pass-through interchange and assessments |
+| `authorization` | Authorization, gateway, capture, AVS, and similar per-attempt service fees | Settled-item markup already classified in `processor_markup` |
+| `monthly` | Monthly account, statement, minimum, batch, or platform administration fees | Equipment service and PCI program fees when separately stated |
+| `pci` | PCI program, non-validation, or compliance-service fees | Penalties unrelated to processing, which belong in `other` with a note |
+| `equipment` | Terminal rental, device service, replacement plan, or connectivity fees charged on the processing statement | Equipment sale principal, financing, or lease obligations outside processing cost |
+| `chargebacks` | Chargeback, retrieval, arbitration, and dispute administration fees | Chargeback transaction principal or lost sale amount |
+| `other` | A processing-related fee that fits no category, with a concise classification note | Refund principal, reserves, taxes withheld, loans/advances, financing principal, or merchant deposits |
+
+Never omit a fee to make a rate look better. If the source statement does not provide enough information to classify a processing-related charge, put it in `other` and document the reason. If the statement mixes periods or currencies and they cannot be separated faithfully, do not publish a v1.1.0 record.

LICENSE.md

@@ -0,0 +1,11 @@
+# Creative Commons Attribution 4.0 International
+
+This work is licensed under the Creative Commons Attribution 4.0 International License.
+
+You are free to share and adapt this material for any purpose, including commercially, provided that you give appropriate credit, link to the license, and indicate whether changes were made. You may not apply legal or technological restrictions that prevent others from doing anything the license permits.
+
+The complete legal code is available at https://creativecommons.org/licenses/by/4.0/legalcode.
+
+Suggested attribution:
+
+> Lifted Payments payment statement audit model — https://liftedpayments.com/payment-processing-statement-audit/

METHODOLOGY.md

@@ -0,0 +1,48 @@
+# Statement audit methodology and limitations
+
+## Purpose
+
+The Lifted Payments Payment Statement Audit Model normalizes one processing statement into comparable monthly totals. It is designed for reproducible arithmetic, fee-taxonomy review, and month-over-month or provider-to-provider comparison. It is not a substitute for the original statement, merchant agreement, card-brand rules, tax advice, legal advice, an accounting opinion, or an interchange-qualification analysis.
+
+## Procedure
+
+1. Confirm that the source covers one USD statement period of no more than 62 inclusive days. If the statement combines currencies or inseparable periods, stop.
+2. Record gross settled purchase volume and its matching settled purchase count. Do not use net deposits, net sales after refunds, authorization volume, or funding totals.
+3. Identify every processing-related charge for the same period. Exclude transaction principal, refund and chargeback principal, reserves, withholding, loan or advance repayment, and equipment financing principal.
+4. Assign each gross charge exactly once to the taxonomy in [`DATA_DICTIONARY.md`](./DATA_DICTIONARY.md). Put ambiguous processing charges in `other` with a note; do not drop them.
+5. Sum the fee groups to `gross_processing_fees`. Record only processing-fee rebates or credits in `statement_credits`. Subtract those credits to obtain `total_processing_fees`.
+6. Compute the effective rate from net processing fees and gross settled purchase volume. Compute average ticket from that same volume and count. Use decimal arithmetic and round half up only at the published precision.
+7. Run the companion validator. Correct the source mapping—not the validator result—when a rule fails. Preserve the source statement privately according to the merchant’s controls; never attach it to this public resource.
+
+## Equations
+
+```text
+gross_processing_fees = exact sum(fee_groups.amount)
+total_processing_fees = gross_processing_fees - statement_credits
+effective_rate = round_half_up(total_processing_fees / card_volume, 6)
+average_ticket = round_half_up(card_volume / transaction_count, 2)
+```
+
+When volume and count are zero, `effective_rate` and `average_ticket` are `null`. Fixed monthly fees may still make `total_processing_fees` positive. A percentage shown to people is `effective_rate × 100`; the JSON value remains a decimal.
+
+## What the effective rate can and cannot show
+
+The rate is an all-in normalization of the included statement costs. It can support consistent comparisons when records use the same basis. It does not isolate provider margin, prove that interchange was qualified correctly, predict a future bill, or guarantee savings. Card mix, ticket size, acceptance channel, rewards mix, disputes, seasonality, statement timing, and fee changes can move the rate without a pricing change.
+
+Comparisons should use multiple representative statements when available and should present absolute dollars, volume, transaction count, fee groups, and rate together. A single rate without its basis and period is not a complete audit.
+
+## Validation architecture
+
+The JSON Schema enforces types, required fields, enums, bounds, and unknown-field rejection. The Python validator additionally enables date-format assertion, parses JSON numbers as `Decimal`, rejects duplicate keys and non-finite values, and enforces cross-field accounting rules. This split is intentional: Draft 2020-12 `format` is annotation by default, and JSON Schema does not express date ordering or arithmetic equality across fields.
+
+Validation errors expose only rule code, JSON Pointer path, and a fixed message. They do not echo submitted values. The shipped corpus contains valid and deliberately invalid synthetic vectors so independent users can reproduce both acceptance and rejection behavior.
+
+## Privacy and security boundary
+
+This model needs statement-level aggregates only. It has no fields for PAN, truncated PAN, cardholder name, expiration date, track data, security codes, PIN/PIN block, bank account or routing numbers, tax or government identifiers, merchant owner data, credentials, tokens, or secrets. Unknown fields are rejected. Notes are scanned for Luhn-valid PAN-like sequences, labeled authentication/bank data, email addresses, and common credential patterns.
+
+Automated screening reduces accidental disclosure; it cannot prove that arbitrary prose contains no personal or confidential information. A human must review any record before public release. Never use this repository or a public dataset mirror to upload a real merchant statement or a record containing merchant-identifying information.
+
+## Corrections and versioning
+
+Published version artifacts and their checksums are immutable. A calculation or contract change receives a new semantic version, GitHub release, and Zenodo version DOI linked by the concept DOI. Metadata-only corrections that do not change released files may be amended at the archive, but the repository documents the correction. Known limitations are disclosed rather than silently “fixed” in prior versions.

README.md

@@ -1,3 +1,90 @@
 ---
 license: cc-by-4.0
+language:
+- en
+pretty_name: "Lifted Payments Payment Statement Audit Model"
+tags:
+- tabular
+- finance
+- payments
+- merchant-services
+- effective-rate
+configs:
+- config_name: default
+  data_files:
+  - split: examples
+    path: examples/payment-statement-audit-example.json
 ---
+
+# Lifted Payments Payment Statement Audit Model
+
+A processor-neutral data contract for turning monthly merchant payment-processing totals into a consistent, comparable audit record. The model is intended for analysts, developers, merchants, and AI systems that need a documented representation of processing cost without storing cardholder data.
+
+This distribution contains version **1.1.0** of the schema, companion validator, spreadsheet template, methodology, adversarial test corpus, and entirely synthetic examples. It is a reusable specification and demonstration package, not a collection of real merchant statements.
+
+## Persistent identity
+
+- Canonical methodology: https://liftedpayments.com/payment-processing-statement-audit/
+- Version DOI: https://doi.org/10.5281/zenodo.21762273
+- Concept DOI: https://doi.org/10.5281/zenodo.21761714
+- Versioned source release: https://github.com/Lifted-Holdings/payment-processing-resources/releases/tag/v1.1.0
+- Source repository: https://github.com/Lifted-Holdings/payment-processing-resources
+
+## Files
+
+| File | Role |
+|---|---|
+| `payment-statement-audit-template.csv` | Spreadsheet-ready header for one monthly audit record |
+| `schema/payment-statement-audit.schema.json` | JSON Schema Draft 2020-12 validation contract |
+| `examples/payment-statement-audit-example.json` | Complete synthetic example record |
+| `DATA_DICTIONARY.md` and `METHODOLOGY.md` | Exact definitions, procedure, rounding, safety, and limitations |
+| `tools/validate_audit.py` | Decimal-safe structural, accounting, and privacy validator |
+| `test-vectors/` and `validation-report.json` | Reproducible acceptance/rejection corpus and result |
+| `CITATION.cff` | Citation metadata |
+| `codemeta.json` | Schema.org and CodeMeta dataset identity |
+| `checksums.txt` | SHA-256 integrity values for the portable data files |
+
+## Core fields
+
+| Field | Meaning |
+|---|---|
+| `statement_period` | Start and end dates covered by the monthly statement |
+| `card_volume` | Total card sales volume for the same period |
+| `transaction_count` | Count of processed transactions |
+| `gross_processing_fees` | Exact sum of gross fee-group charges |
+| `statement_credits` | Processing-fee credits or rebates, reported separately |
+| `total_processing_fees` | Gross fees minus statement credits |
+| `effective_rate` | Net processing fees divided by gross settled purchase volume, stored as a decimal |
+| `pricing_model` | The pricing structure observed in the statement |
+| `fee_groups` | Fees grouped into stable comparison categories |
+| `review_notes` | Analyst notes, assumptions, and data-quality boundaries |
+
+The core calculation is:
+
+```text
+effective rate = net processing fees / gross settled purchase volume
+```
+
+For example, `0.022918` displays as `2.2918%` after multiplying by 100 for presentation.
+
+## Intended uses
+
+- Normalize statement totals before comparing months or proposals.
+- Validate an audit record against a stable machine-readable schema.
+- Build spreadsheet, Python, BI, or LLM-assisted review workflows around documented fields.
+- Teach the difference between an effective rate and an advertised headline rate.
+- Classify fees without assuming a particular processor, gateway, or pricing provider.
+
+## Limitations and safety
+
+The model does not determine legal compliance, tax treatment, network qualification, underwriting eligibility, accounting correctness, or future pricing. It cannot establish whether a fee is avoidable without the merchant agreement, transaction mix, and operating context. Automated privacy screening reduces accidental disclosure but cannot prove arbitrary notes contain no confidential information; a human review remains required before public release.
+
+The included example is synthetic and describes no real merchant. Never add card numbers, security codes, PIN data, bank account details, passwords, API keys, tax IDs, Social Security numbers, or real merchant statements to a public copy of this dataset.
+
+## Citation
+
+> Lifted Payments. (2026). *Lifted Payments Payment Statement Audit Model* (Version 1.1.0). Zenodo. https://doi.org/10.5281/zenodo.21762273
+
+## License
+
+Released under [Creative Commons Attribution 4.0 International](https://creativecommons.org/licenses/by/4.0/). Attribution is required when the model or its documentation is reused.

RELEASE-MANIFEST.json

@@ -0,0 +1,48 @@
+{
+  "title": "Lifted Payments Payment Statement Audit Model",
+  "version": "1.1.0",
+  "version_doi": "10.5281/zenodo.21762273",
+  "concept_doi": "10.5281/zenodo.21761714",
+  "canonical_url": "https://liftedpayments.com/payment-processing-statement-audit/",
+  "source_release": "https://github.com/Lifted-Holdings/payment-processing-resources/releases/tag/v1.1.0",
+  "license": "CC-BY-4.0",
+  "files": [
+    ".zenodo.json",
+    "CITATION.cff",
+    "checksums.txt",
+    "codemeta.json",
+    "DATA_DICTIONARY.md",
+    "distribution/huggingface/README.md",
+    "distribution/kaggle/dataset-metadata.json",
+    "distribution/kaggle/README.md",
+    "examples/payment-statement-audit-example.json",
+    "LICENSE.md",
+    "llms.txt",
+    "METHODOLOGY.md",
+    "payment-statement-audit-template.csv",
+    "README.md",
+    "RELEASE-MANIFEST.json",
+    "requirements-validation.txt",
+    "schema/payment-statement-audit.schema.json",
+    "test-vectors/invalid/activity-mismatch.json",
+    "test-vectors/invalid/duplicate-category.json",
+    "test-vectors/invalid/fee-sum-mismatch.json",
+    "test-vectors/invalid/fractional-cent.json",
+    "test-vectors/invalid/invalid-date.json",
+    "test-vectors/invalid/net-fee-mismatch.json",
+    "test-vectors/invalid/overlong-period.json",
+    "test-vectors/invalid/overprecise-rate.json",
+    "test-vectors/invalid/security-data-in-note.json",
+    "test-vectors/invalid/reversed-period.json",
+    "test-vectors/invalid/unknown-field.json",
+    "test-vectors/invalid/wrong-average-ticket.json",
+    "test-vectors/invalid/wrong-effective-rate.json",
+    "test-vectors/manifest.json",
+    "test-vectors/valid/standard-month.json",
+    "test-vectors/valid/zero-activity-month.json",
+    "tools/publication_gate.py",
+    "tools/update_checksums.py",
+    "tools/validate_audit.py",
+    "validation-report.json"
+  ]
+}

checksums.txt

@@ -0,0 +1,36 @@
+955f069a776b7a49ac99d6c9ccf7f8a7f065f6bef89344f819b8bb2f940c67f2 .zenodo.json
+c5b80e64c2f01e4622a086bca302b91a46061b806dc26521ed691a97fab31423 CITATION.cff
+6f37348b42d96d8d1ca6385033bfda91efc26353709eeb46e91e38db9801a323 DATA_DICTIONARY.md
+248c65ad6ddbd9dd29a4b753d312a15016a8062d55646e19e222f0ac42485b96 LICENSE.md
+3a8a8390a9d890c522c5f20c40281b169bfc5d3b19c11ee2705753402aad6857 METHODOLOGY.md
+2d4c2f6f581dd68af3dd9a7f7f97b1f3fd04c5a55af963a8d57db7dc2ed4f615 README.md
+e8e72a5d203d0773dc82ca219c12bb9fec332ef52515b08b0a27c9964e982697 RELEASE-MANIFEST.json
+fef0aa9f3e2db36c79020b1084102a454d6734ed8e5e04fd1c61d84eef688c8e codemeta.json
+fd10af02d6d9a986f8899d9eb3a4023c8374441f2e02632c95ab7cc427cc5f04 distribution/huggingface/README.md
+23904ebf11ecfae3b0df5979239df82b143b12ff48e06cff0ac5d9bbb2eb6f96 distribution/kaggle/README.md
+7187b4977f7c3a518475c9d0f989a7d8cc71b8e5a23f5b10608bad8b8fcdf16f distribution/kaggle/dataset-metadata.json
+7a3299b4490d0e7f0c1a99a48859bce9742f632d8796699d80a48221e9fa38af examples/payment-statement-audit-example.json
+f08d1dc8fe55a054d2947e6c57558c2daa632caf86f0e6296b9e36bc7a85de45 llms.txt
+51cde2dd0d9da13e47c50228f96f8cc624662b5edcccb3f95719f53a79a1a47c payment-statement-audit-template.csv
+d53f1737b5cb16cd8ad3c79ae4082ff35b0f120eb45bd502a042b3e5f275ac1f requirements-validation.txt
+5979ec9c587be20ae723879f3863edb1f5a78ccddc848ca9a183b58532271730 schema/payment-statement-audit.schema.json
+3bad5c0b256a0a65640515c00d6e1eea316039f57e3ec08a6809eee4c75f176a test-vectors/invalid/activity-mismatch.json
+2ee2c9552d3728bcddce248cf3a3b8c12ec06c5923f48412688e544c69cdb78a test-vectors/invalid/duplicate-category.json
+57f100181eb71060b16d3ae9e1861ef1eb79940f0bf7f4f1e618a97bb1e4415d test-vectors/invalid/fee-sum-mismatch.json
+dd522dff07da399c5fc46d2d02a4cb9109c7f1860ec58a4849392e9aff853f52 test-vectors/invalid/fractional-cent.json
+23c4e68b176b807df6738a4b0a9a8adbddbf9ddaee26d0b4262a6905652af951 test-vectors/invalid/invalid-date.json
+0ef3f62501948cd15f7d69b4b64f43c78cb110f9937f5a2115e2e7e7f85eb0c7 test-vectors/invalid/net-fee-mismatch.json
+caeb952d6e2c93597b6f7def52616e7b390c8f8807b9740a4ae6acb6ecba1d30 test-vectors/invalid/overlong-period.json
+fb401b20ccfa0b3278948e60dbc7efc9e6c140d9facc7a58ddceb09ebfa32029 test-vectors/invalid/overprecise-rate.json
+96aa4e395b6fb9154673602441429aaf3cb3cb962899f3f9b355b4cfb0fb6d17 test-vectors/invalid/reversed-period.json
+5a1821ccd329b53e393dd27d6eca8c4da7ed09f9963d36efe7eb2bfe7f47c0d9 test-vectors/invalid/security-data-in-note.json
+a102b3b69c9260579982d5d668a57ab5494d1baba89fe8d93cd1b5ef5d564572 test-vectors/invalid/unknown-field.json
+8520c8dc0244c121e85e39ae63af1846e15acf902355afa0ce515838c6160b7b test-vectors/invalid/wrong-average-ticket.json
+b185d1eb11f805c1dac0e0a5aa69be8bb35fbed1079673a3e8a2abba45d83a36 test-vectors/invalid/wrong-effective-rate.json
+067df78c1143d18c5daa86467fd51ef760653a4aa7b15213eb381bd56dd39377 test-vectors/manifest.json
+d73ed747b481e60c3c4502a1738997f04a6a5c63ceb1268ebd4e4fb8e3e0baea test-vectors/valid/standard-month.json
+9a0f4872a6b588d246954727deb02bc5b7e82bac9921efb5ebf1e0b27a558a10 test-vectors/valid/zero-activity-month.json
+405138c1c7f07a9d50b1285d94ddb8222283bde8c30c4f8ffc73fe909a71ae12 tools/publication_gate.py
+9efff7ec3bfff067abaaf8a5d2c5008c3aaf0bf7b25c49ff623c37552de6bb10 tools/update_checksums.py
+876cc506196772369a5b2afcc2e8f72e072268db1cdf61dea0978ea81ae27b0b tools/validate_audit.py
+1498a6ad7c1c48f48fe4b15bc8ac1a2188fdb557f1e51b159b8dca673b6839b2 validation-report.json

codemeta.json

@@ -0,0 +1,39 @@
+{
+  "@context": "https://doi.org/10.5063/schema/codemeta-2.0",
+  "@type": "Dataset",
+  "name": "Lifted Payments Payment Statement Audit Model",
+  "description": "A processor-neutral, validated model for normalizing monthly merchant payment-processing statements without cardholder data.",
+  "version": "1.1.0",
+  "datePublished": "2026-08-02",
+  "license": "https://creativecommons.org/licenses/by/4.0/",
+  "identifier": "https://doi.org/10.5281/zenodo.21762273",
+  "url": "https://liftedpayments.com/payment-processing-statement-audit/",
+  "sameAs": [
+    "https://doi.org/10.5281/zenodo.21762273",
+    "https://doi.org/10.5281/zenodo.21761714",
+    "https://zenodo.org/records/21762273"
+  ],
+  "codeRepository": "https://github.com/Lifted-Holdings/payment-processing-resources",
+  "creator": {
+    "@type": "Organization",
+    "name": "Lifted Payments",
+    "url": "https://liftedpayments.com/"
+  },
+  "publisher": {
+    "@type": "Organization",
+    "name": "Lifted Holdings",
+    "url": "https://liftedholdings.com/"
+  },
+  "keywords": [
+    "payment processing",
+    "merchant services",
+    "effective rate",
+    "statement audit",
+    "fintech",
+    "JSON Schema",
+    "payments data",
+    "cost analysis"
+  ],
+  "isAccessibleForFree": true,
+  "inLanguage": "en"
+}

examples/payment-statement-audit-example.json

@@ -0,0 +1,26 @@
+{
+  "schema_version": "1.1.0",
+  "calculation_basis": "gross_settled_purchase_volume_and_net_processing_fees",
+  "statement_period": { "start": "2026-06-01", "end": "2026-06-30" },
+  "currency": "USD",
+  "card_volume": 125000.00,
+  "transaction_count": 1860,
+  "gross_processing_fees": 2864.75,
+  "statement_credits": 0.00,
+  "total_processing_fees": 2864.75,
+  "effective_rate": 0.022918,
+  "average_ticket": 67.20,
+  "pricing_model": "interchange_plus",
+  "fee_groups": [
+    { "category": "interchange", "amount": 1849.25, "notes": "Illustrative network interchange total." },
+    { "category": "assessments", "amount": 171.50, "notes": "Illustrative network assessments." },
+    { "category": "processor_markup", "amount": 575.00, "notes": "Illustrative percentage and per-item markup." },
+    { "category": "authorization", "amount": 186.00, "notes": "Illustrative authorization fees." },
+    { "category": "monthly", "amount": 49.00, "notes": "Illustrative account and statement fees." },
+    { "category": "pci", "amount": 34.00, "notes": "Illustrative compliance-program fee." }
+  ],
+  "review_notes": [
+    "All figures are synthetic and do not describe a real merchant.",
+    "Fee groups reconcile to gross processing fees; processing-fee credits are reported separately."
+  ]
+}

payment-statement-audit-template.csv

@@ -0,0 +1,2 @@
+schema_version,calculation_basis,statement_start,statement_end,currency,card_volume,transaction_count,gross_processing_fees,statement_credits,total_processing_fees,effective_rate,average_ticket,pricing_model,interchange,assessments,processor_markup,authorization,monthly,pci,equipment,chargebacks,other,notes
+1.1.0,gross_settled_purchase_volume_and_net_processing_fees,2026-06-01,2026-06-30,USD,125000.00,1860,2864.75,0.00,2864.75,0.022918,67.20,interchange_plus,1849.25,171.50,575.00,186.00,49.00,34.00,0.00,0.00,0.00,Synthetic example only; replace every value with figures from your own statement

requirements-validation.txt

@@ -0,0 +1,5 @@
+attrs==26.1.0
+jsonschema==4.26.0
+jsonschema-specifications==2025.9.1
+referencing==0.37.0
+rpds-py==2026.6.3

schema/payment-statement-audit.schema.json

@@ -0,0 +1,155 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://liftedpayments.com/assets/data/payment-statement-audit.schema.json",
+  "title": "Lifted Payments Payment Statement Audit Model",
+  "description": "A processor-neutral contract for normalizing statement-level merchant processing totals without cardholder or bank-account data. Cross-field accounting and privacy rules are enforced by tools/validate_audit.py.",
+  "type": "object",
+  "required": [
+    "schema_version",
+    "calculation_basis",
+    "statement_period",
+    "currency",
+    "card_volume",
+    "transaction_count",
+    "gross_processing_fees",
+    "statement_credits",
+    "total_processing_fees",
+    "effective_rate",
+    "average_ticket",
+    "pricing_model",
+    "fee_groups"
+  ],
+  "properties": {
+    "schema_version": {
+      "const": "1.1.0",
+      "description": "Version of this data contract."
+    },
+    "calculation_basis": {
+      "const": "gross_settled_purchase_volume_and_net_processing_fees",
+      "description": "Declares the numerator and denominator convention used by this release."
+    },
+    "statement_period": {
+      "type": "object",
+      "required": ["start", "end"],
+      "properties": {
+        "start": {
+          "type": "string",
+          "format": "date",
+          "description": "First calendar date covered by the statement, inclusive."
+        },
+        "end": {
+          "type": "string",
+          "format": "date",
+          "description": "Last calendar date covered by the statement, inclusive."
+        }
+      },
+      "additionalProperties": false
+    },
+    "currency": {
+      "const": "USD",
+      "description": "All monetary fields use US dollars. Mixed-currency records are invalid."
+    },
+    "card_volume": {
+      "$ref": "#/$defs/money",
+      "description": "Gross settled purchase volume for the statement period, before refunds, chargebacks, or funding adjustments."
+    },
+    "transaction_count": {
+      "type": "integer",
+      "minimum": 0,
+      "maximum": 1000000000,
+      "description": "Count of settled purchase transactions included in card_volume."
+    },
+    "gross_processing_fees": {
+      "$ref": "#/$defs/money",
+      "description": "Gross processing-related charges before statement_credits; equals the sum of fee_groups."
+    },
+    "statement_credits": {
+      "$ref": "#/$defs/money",
+      "description": "Processing-fee credits or rebates applied on the statement. Transaction refunds and funding adjustments are excluded."
+    },
+    "total_processing_fees": {
+      "$ref": "#/$defs/money",
+      "description": "Net processing fees: gross_processing_fees minus statement_credits."
+    },
+    "effective_rate": {
+      "description": "total_processing_fees divided by card_volume, expressed as a decimal rounded to six places; null when card_volume is zero.",
+      "oneOf": [
+        { "$ref": "#/$defs/rate" },
+        { "type": "null" }
+      ]
+    },
+    "average_ticket": {
+      "description": "card_volume divided by transaction_count, rounded to cents; null when transaction_count is zero.",
+      "oneOf": [
+        { "$ref": "#/$defs/money" },
+        { "type": "null" }
+      ]
+    },
+    "pricing_model": {
+      "type": "string",
+      "enum": [
+        "interchange_plus",
+        "flat_rate",
+        "tiered",
+        "subscription",
+        "dual_pricing",
+        "unknown"
+      ],
+      "description": "Observed statement pricing presentation, not a legal or qualification determination."
+    },
+    "fee_groups": {
+      "type": "array",
+      "minItems": 1,
+      "maxItems": 9,
+      "description": "Gross, nonnegative processing charges grouped once by category. Categories must be unique.",
+      "items": {
+        "type": "object",
+        "required": ["category", "amount"],
+        "properties": {
+          "category": {
+            "type": "string",
+            "enum": [
+              "interchange",
+              "assessments",
+              "processor_markup",
+              "authorization",
+              "monthly",
+              "pci",
+              "equipment",
+              "chargebacks",
+              "other"
+            ]
+          },
+          "amount": { "$ref": "#/$defs/money" },
+          "notes": { "$ref": "#/$defs/note" }
+        },
+        "additionalProperties": false
+      }
+    },
+    "review_notes": {
+      "type": "array",
+      "maxItems": 20,
+      "items": { "$ref": "#/$defs/note" },
+      "description": "Optional audit explanations only. Never include merchant identity, card data, bank data, credentials, or secrets."
+    }
+  },
+  "$defs": {
+    "money": {
+      "type": "number",
+      "minimum": 0,
+      "maximum": 999999999999.99,
+      "description": "A nonnegative USD amount with no more than two decimal places. Decimal precision is enforced by the companion validator."
+    },
+    "rate": {
+      "type": "number",
+      "minimum": 0,
+      "description": "A nonnegative decimal rate with no more than six decimal places."
+    },
+    "note": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 500
+    }
+  },
+  "additionalProperties": false
+}

test-vectors/invalid/activity-mismatch.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":0.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":null,"average_ticket":0.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
+}

test-vectors/invalid/duplicate-category.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":1.00},{"category":"processor_markup","amount":1.00}]
+}

test-vectors/invalid/fee-sum-mismatch.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.01,"statement_credits":0.00,"total_processing_fees":2.01,"effective_rate":0.020100,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
+}

test-vectors/invalid/fractional-cent.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.001,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
+}

test-vectors/invalid/invalid-date.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-02-01","end":"2026-02-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
+}

test-vectors/invalid/net-fee-mismatch.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.50,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
+}

test-vectors/invalid/overlong-period.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-01-01","end":"2026-04-01"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
+}

test-vectors/invalid/overprecise-rate.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.0200001,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
+}

test-vectors/invalid/reversed-period.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-07-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
+}

test-vectors/invalid/security-data-in-note.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}],"review_notes":["Synthetic security-code label with digits: CVV 123"]
+}

test-vectors/invalid/unknown-field.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}],"merchant_name":"Do not collect this"
+}

test-vectors/invalid/wrong-average-ticket.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":2,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":0.020000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
+}

test-vectors/invalid/wrong-effective-rate.json

@@ -0,0 +1,3 @@
+{
+  "schema_version":"1.1.0","calculation_basis":"gross_settled_purchase_volume_and_net_processing_fees","statement_period":{"start":"2026-06-01","end":"2026-06-30"},"currency":"USD","card_volume":100.00,"transaction_count":1,"gross_processing_fees":2.00,"statement_credits":0.00,"total_processing_fees":2.00,"effective_rate":2.000000,"average_ticket":100.00,"pricing_model":"flat_rate","fee_groups":[{"category":"processor_markup","amount":2.00}]
+}

test-vectors/manifest.json

@@ -0,0 +1,17 @@
+{
+  "invalid": {
+    "activity-mismatch.json": ["activity_pair"],
+    "duplicate-category.json": ["duplicate_fee_category"],
+    "fee-sum-mismatch.json": ["fee_group_reconciliation"],
+    "fractional-cent.json": ["money_precision"],
+    "invalid-date.json": ["schema_format"],
+    "net-fee-mismatch.json": ["net_fee_reconciliation"],
+    "overlong-period.json": ["period_duration"],
+    "overprecise-rate.json": ["rate_precision"],
+    "security-data-in-note.json": ["prohibited_payment_data"],
+    "reversed-period.json": ["period_order"],
+    "unknown-field.json": ["schema_additionalProperties"],
+    "wrong-average-ticket.json": ["average_ticket_mismatch"],
+    "wrong-effective-rate.json": ["effective_rate_mismatch"]
+  }
+}

test-vectors/valid/standard-month.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": "1.1.0",
+  "calculation_basis": "gross_settled_purchase_volume_and_net_processing_fees",
+  "statement_period": {"start": "2026-06-01", "end": "2026-06-30"},
+  "currency": "USD",
+  "card_volume": 125000.00,
+  "transaction_count": 1860,
+  "gross_processing_fees": 2864.75,
+  "statement_credits": 0.00,
+  "total_processing_fees": 2864.75,
+  "effective_rate": 0.022918,
+  "average_ticket": 67.20,
+  "pricing_model": "interchange_plus",
+  "fee_groups": [
+    {"category": "interchange", "amount": 1849.25},
+    {"category": "assessments", "amount": 171.50},
+    {"category": "processor_markup", "amount": 575.00},
+    {"category": "authorization", "amount": 186.00},
+    {"category": "monthly", "amount": 49.00},
+    {"category": "pci", "amount": 34.00}
+  ],
+  "review_notes": ["Synthetic validation vector only."]
+}

test-vectors/valid/zero-activity-month.json

@@ -0,0 +1,16 @@
+{
+  "schema_version": "1.1.0",
+  "calculation_basis": "gross_settled_purchase_volume_and_net_processing_fees",
+  "statement_period": {"start": "2026-06-01", "end": "2026-06-30"},
+  "currency": "USD",
+  "card_volume": 0.00,
+  "transaction_count": 0,
+  "gross_processing_fees": 49.00,
+  "statement_credits": 0.00,
+  "total_processing_fees": 49.00,
+  "effective_rate": null,
+  "average_ticket": null,
+  "pricing_model": "unknown",
+  "fee_groups": [{"category": "monthly", "amount": 49.00}],
+  "review_notes": ["Synthetic zero-activity validation vector only."]
+}

tools/validate_audit.py

@@ -0,0 +1,608 @@
+#!/usr/bin/env python3
+"""Validate Lifted Payments statement-audit records without echoing input values."""
+
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import re
+from dataclasses import asdict, dataclass
+from datetime import date
+from decimal import Decimal, InvalidOperation, ROUND_HALF_UP
+from importlib.metadata import version as package_version
+from pathlib import Path
+from typing import Any, Iterable
+
+from jsonschema import Draft202012Validator, FormatChecker, validators
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SCHEMA_PATH = ROOT / "schema/payment-statement-audit.schema.json"
+VALIDATOR_VERSION = "1.1.0"
+VALIDATION_DEPENDENCIES = (
+    "attrs",
+    "jsonschema",
+    "jsonschema-specifications",
+    "referencing",
+    "rpds-py",
+)
+MAX_PERIOD_DAYS = 62
+MAX_INPUT_BYTES = 1_000_000
+MAX_INPUT_DEPTH = 32
+MONEY_QUANTUM = Decimal("0.01")
+RATE_QUANTUM = Decimal("0.000001")
+FEE_CATEGORIES = (
+    "interchange",
+    "assessments",
+    "processor_markup",
+    "authorization",
+    "monthly",
+    "pci",
+    "equipment",
+    "chargebacks",
+    "other",
+)
+CSV_HEADER = (
+    "schema_version",
+    "calculation_basis",
+    "statement_start",
+    "statement_end",
+    "currency",
+    "card_volume",
+    "transaction_count",
+    "gross_processing_fees",
+    "statement_credits",
+    "total_processing_fees",
+    "effective_rate",
+    "average_ticket",
+    "pricing_model",
+    *FEE_CATEGORIES,
+    "notes",
+)
+
+_PAN_CANDIDATE = re.compile(r"(?<!\d)(?:\d[ -]?){13,19}(?!\d)")
+_SSN = re.compile(r"(?<!\d)\d{3}-\d{2}-\d{4}(?!\d)")
+_EMAIL = re.compile(r"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b", re.I)
+_AUTHENTICATION_LABEL = re.compile(
+    r"\b(?:cvv2?|cvc2?|cid|security\s*code|pin(?:\s*block)?)\b",
+    re.I,
+)
+_BANK_VALUE = re.compile(
+    r"\b(?:routing|account)(?:\s*(?:number|no))?\b[^\r\n\d]{0,12}\d{4,}",
+    re.I,
+)
+_LABELED_CREDENTIAL = re.compile(
+    r"\b(?:password|api[_ -]?key|bearer|secret|access[_ -]?token)\b"
+    r"\s*(?::|=|is)\s*[A-Za-z0-9_-]{3,}",
+    re.I,
+)
+_CREDENTIAL = re.compile(
+    r"\b(?:sk|pk|ghp|github_pat|hf)_[A-Za-z0-9_-]{12,}\b", re.I
+)
+_PROHIBITED_KEY = re.compile(
+    r"(?:pan|card_?number|cvv|cvc|security_?code|pin_?block|routing_?number|"
+    r"bank_?account|account_?number|ssn|password|api_?key|secret|token)",
+    re.I,
+)
+
+
+@dataclass(frozen=True, order=True)
+class ValidationIssue:
+    code: str
+    path: str
+    message: str
+
+    def to_dict(self) -> dict[str, str]:
+        return asdict(self)
+
+
+def _reject_constant(_: str) -> None:
+    raise ValueError("non_finite_number: JSON numbers must be finite")
+
+
+def _unique_object(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for key, value in pairs:
+        if key in result:
+            raise ValueError("duplicate_key: JSON object keys must be unique")
+        result[key] = value
+    return result
+
+
+def loads_record(source: str) -> dict[str, Any]:
+    if len(source.encode("utf-8")) > MAX_INPUT_BYTES:
+        raise ValueError("input_size: audit record exceeds the one-megabyte limit")
+    try:
+        result = json.loads(
+            source,
+            parse_float=Decimal,
+            parse_int=int,
+            parse_constant=_reject_constant,
+            object_pairs_hook=_unique_object,
+        )
+    except (json.JSONDecodeError, RecursionError) as exc:
+        raise ValueError("invalid_json: input is not valid JSON") from exc
+    if not isinstance(result, dict):
+        raise ValueError("invalid_root: audit record must be a JSON object")
+    stack: list[tuple[Any, int]] = [(result, 1)]
+    while stack:
+        value, depth = stack.pop()
+        if depth > MAX_INPUT_DEPTH:
+            raise ValueError("input_depth: audit record is nested too deeply")
+        if isinstance(value, dict):
+            stack.extend((child, depth + 1) for child in value.values())
+        elif isinstance(value, list):
+            stack.extend((child, depth + 1) for child in value)
+    return result
+
+
+def load_record(path: Path | str) -> dict[str, Any]:
+    path = Path(path)
+    if path.stat().st_size > MAX_INPUT_BYTES:
+        raise ValueError("input_size: audit record exceeds the one-megabyte limit")
+    return loads_record(path.read_text(encoding="utf-8"))
+
+
+def _schema_validator() -> Draft202012Validator:
+    schema = json.loads(SCHEMA_PATH.read_text(encoding="utf-8"))
+    Draft202012Validator.check_schema(schema)
+    number_check = Draft202012Validator.TYPE_CHECKER.redefine(
+        "number",
+        lambda checker, instance: (
+            not isinstance(instance, bool)
+            and isinstance(instance, (int, float, Decimal))
+        ),
+    )
+    decimal_validator = validators.extend(
+        Draft202012Validator, type_checker=number_check
+    )
+    return decimal_validator(schema, format_checker=FormatChecker())
+
+
+def _pointer(parts: Iterable[Any]) -> str:
+    encoded = [str(part).replace("~", "~0").replace("/", "~1") for part in parts]
+    return "/" + "/".join(encoded) if encoded else "/"
+
+
+def _schema_issues(record: dict[str, Any]) -> list[ValidationIssue]:
+    issues = []
+    for error in sorted(
+        _schema_validator().iter_errors(record),
+        key=lambda error: _pointer(error.absolute_path),
+    ):
+        validator_name = str(error.validator or "validation")
+        issues.append(
+            ValidationIssue(
+                code=f"schema_{validator_name}",
+                path=_pointer(error.absolute_path),
+                message=f"Record violates the schema {validator_name} rule.",
+            )
+        )
+    return issues
+
+
+def _decimal(value: Any) -> Decimal | None:
+    if isinstance(value, bool) or value is None:
+        return None
+    try:
+        result = value if isinstance(value, Decimal) else Decimal(str(value))
+    except (InvalidOperation, ValueError):
+        return None
+    return result if result.is_finite() else None
+
+
+def _has_scale(value: Any, places: int) -> bool:
+    number = _decimal(value)
+    return number is not None and number.as_tuple().exponent >= -places
+
+
+def _luhn_valid(digits: str) -> bool:
+    total = 0
+    parity = len(digits) % 2
+    for index, char in enumerate(digits):
+        value = int(char)
+        if index % 2 == parity:
+            value *= 2
+            if value > 9:
+                value -= 9
+        total += value
+    return total % 10 == 0
+
+
+def _string_contains_prohibited_data(value: str) -> bool:
+    if _SSN.search(value) or _EMAIL.search(value) or _CREDENTIAL.search(value):
+        return True
+    for candidate in _PAN_CANDIDATE.finditer(value):
+        digits = re.sub(r"\D", "", candidate.group(0))
+        if 13 <= len(digits) <= 19 and _luhn_valid(digits):
+            return True
+    if (
+        _AUTHENTICATION_LABEL.search(value)
+        or _BANK_VALUE.search(value)
+        or _LABELED_CREDENTIAL.search(value)
+    ):
+        return True
+    return False
+
+
+def _privacy_issues(value: Any, path: tuple[Any, ...] = ()) -> list[ValidationIssue]:
+    issues: list[ValidationIssue] = []
+    if isinstance(value, dict):
+        for key, child in value.items():
+            child_path = (*path, key)
+            if _PROHIBITED_KEY.search(key):
+                issues.append(
+                    ValidationIssue(
+                        "prohibited_field",
+                        _pointer(child_path),
+                        "A prohibited payment, identity, bank, or credential field is present.",
+                    )
+                )
+            issues.extend(_privacy_issues(child, child_path))
+    elif isinstance(value, list):
+        for index, child in enumerate(value):
+            issues.extend(_privacy_issues(child, (*path, index)))
+    elif isinstance(value, str) and _string_contains_prohibited_data(value):
+        issues.append(
+            ValidationIssue(
+                "prohibited_payment_data",
+                _pointer(path),
+                "Text may contain prohibited payment, identity, bank, or credential data.",
+            )
+        )
+    return issues
+
+
+def _semantic_issues(record: dict[str, Any]) -> list[ValidationIssue]:
+    issues: list[ValidationIssue] = []
+
+    period = record.get("statement_period")
+    if isinstance(period, dict):
+        try:
+            start = date.fromisoformat(period["start"])
+            end = date.fromisoformat(period["end"])
+        except (KeyError, TypeError, ValueError):
+            start = end = None
+        if start is not None and end is not None:
+            if end < start:
+                issues.append(
+                    ValidationIssue(
+                        "period_order",
+                        "/statement_period",
+                        "Statement period end must not precede start.",
+                    )
+                )
+            elif (end - start).days + 1 > MAX_PERIOD_DAYS:
+                issues.append(
+                    ValidationIssue(
+                        "period_duration",
+                        "/statement_period",
+                        f"Statement period must cover no more than {MAX_PERIOD_DAYS} inclusive days.",
+                    )
+                )
+
+    money_paths: list[tuple[str, Any]] = [
+        (f"/{name}", record.get(name))
+        for name in (
+            "card_volume",
+            "gross_processing_fees",
+            "statement_credits",
+            "total_processing_fees",
+            "average_ticket",
+        )
+        if record.get(name) is not None
+    ]
+    groups = record.get("fee_groups")
+    if isinstance(groups, list):
+        for index, group in enumerate(groups):
+            if isinstance(group, dict) and group.get("amount") is not None:
+                money_paths.append((f"/fee_groups/{index}/amount", group["amount"]))
+    for path, value in money_paths:
+        if _decimal(value) is not None and not _has_scale(value, 2):
+            issues.append(
+                ValidationIssue(
+                    "money_precision",
+                    path,
+                    "USD amounts must use no more than two decimal places.",
+                )
+            )
+
+    rate = record.get("effective_rate")
+    if rate is not None and _decimal(rate) is not None and not _has_scale(rate, 6):
+        issues.append(
+            ValidationIssue(
+                "rate_precision",
+                "/effective_rate",
+                "Effective rate must use no more than six decimal places.",
+            )
+        )
+
+    if isinstance(groups, list):
+        categories = [
+            group.get("category") for group in groups if isinstance(group, dict)
+        ]
+        if len(categories) != len(set(categories)):
+            issues.append(
+                ValidationIssue(
+                    "duplicate_fee_category",
+                    "/fee_groups",
+                    "Each fee category may appear at most once.",
+                )
+            )
+        amounts = [
+            _decimal(group.get("amount"))
+            for group in groups
+            if isinstance(group, dict)
+        ]
+        gross = _decimal(record.get("gross_processing_fees"))
+        if gross is not None and amounts and all(amount is not None for amount in amounts):
+            if sum((amount for amount in amounts if amount is not None), Decimal("0")) != gross:
+                issues.append(
+                    ValidationIssue(
+                        "fee_group_reconciliation",
+                        "/gross_processing_fees",
+                        "Fee-group amounts must exactly equal gross processing fees at cent precision.",
+                    )
+                )
+
+    gross = _decimal(record.get("gross_processing_fees"))
+    credits = _decimal(record.get("statement_credits"))
+    net = _decimal(record.get("total_processing_fees"))
+    if gross is not None and credits is not None and net is not None:
+        if gross - credits != net:
+            issues.append(
+                ValidationIssue(
+                    "net_fee_reconciliation",
+                    "/total_processing_fees",
+                    "Net processing fees must exactly equal gross fees minus statement credits.",
+                )
+            )
+
+    volume = _decimal(record.get("card_volume"))
+    count = record.get("transaction_count")
+    count_is_integer = isinstance(count, int) and not isinstance(count, bool)
+    if volume is not None and count_is_integer:
+        if (volume == 0) != (count == 0):
+            issues.append(
+                ValidationIssue(
+                    "activity_pair",
+                    "/transaction_count",
+                    "Card volume and settled transaction count must both be zero or both be positive.",
+                )
+            )
+
+        if volume == 0:
+            if rate is not None:
+                issues.append(
+                    ValidationIssue(
+                        "zero_volume_rate",
+                        "/effective_rate",
+                        "Effective rate must be null when card volume is zero.",
+                    )
+                )
+        elif net is not None:
+            observed_rate = _decimal(rate)
+            expected_rate = (net / volume).quantize(RATE_QUANTUM, rounding=ROUND_HALF_UP)
+            if observed_rate != expected_rate:
+                issues.append(
+                    ValidationIssue(
+                        "effective_rate_mismatch",
+                        "/effective_rate",
+                        "Effective rate does not match net fees divided by card volume at six-decimal rounding.",
+                    )
+                )
+
+        ticket = record.get("average_ticket")
+        if count == 0:
+            if ticket is not None:
+                issues.append(
+                    ValidationIssue(
+                        "zero_count_ticket",
+                        "/average_ticket",
+                        "Average ticket must be null when transaction count is zero.",
+                    )
+                )
+        elif volume is not None:
+            observed_ticket = _decimal(ticket)
+            expected_ticket = (volume / Decimal(count)).quantize(
+                MONEY_QUANTUM, rounding=ROUND_HALF_UP
+            )
+            if observed_ticket != expected_ticket:
+                issues.append(
+                    ValidationIssue(
+                        "average_ticket_mismatch",
+                        "/average_ticket",
+                        "Average ticket does not match card volume divided by transaction count at cent rounding.",
+                    )
+                )
+
+    return issues
+
+
+def validate_record(record: dict[str, Any]) -> list[ValidationIssue]:
+    issues = _schema_issues(record)
+    issues.extend(_semantic_issues(record))
+    issues.extend(_privacy_issues(record))
+    return sorted(set(issues))
+
+
+def validation_result(record: dict[str, Any]) -> dict[str, Any]:
+    issues = validate_record(record)
+    return {
+        "validator_version": VALIDATOR_VERSION,
+        "status": "valid" if not issues else "invalid",
+        "issue_count": len(issues),
+        "issues": [issue.to_dict() for issue in issues],
+    }
+
+
+def _record_from_csv(row: dict[str, str]) -> dict[str, Any]:
+    groups = []
+    for category in FEE_CATEGORIES:
+        amount = Decimal(row[category])
+        if amount != 0:
+            groups.append({"category": category, "amount": amount})
+    return {
+        "schema_version": row["schema_version"],
+        "calculation_basis": row["calculation_basis"],
+        "statement_period": {
+            "start": row["statement_start"],
+            "end": row["statement_end"],
+        },
+        "currency": row["currency"],
+        "card_volume": Decimal(row["card_volume"]),
+        "transaction_count": int(row["transaction_count"]),
+        "gross_processing_fees": Decimal(row["gross_processing_fees"]),
+        "statement_credits": Decimal(row["statement_credits"]),
+        "total_processing_fees": Decimal(row["total_processing_fees"]),
+        "effective_rate": (
+            None if not row["effective_rate"] else Decimal(row["effective_rate"])
+        ),
+        "average_ticket": (
+            None if not row["average_ticket"] else Decimal(row["average_ticket"])
+        ),
+        "pricing_model": row["pricing_model"],
+        "fee_groups": groups or [{"category": "other", "amount": Decimal("0.00")}],
+        "review_notes": [row["notes"]] if row["notes"] else [],
+    }
+
+
+def validate_csv_template(path: Path | str) -> list[ValidationIssue]:
+    issues: list[ValidationIssue] = []
+    try:
+        with Path(path).open("r", encoding="utf-8", newline="") as handle:
+            reader = csv.DictReader(handle)
+            if tuple(reader.fieldnames or ()) != CSV_HEADER:
+                return [
+                    ValidationIssue(
+                        "csv_header",
+                        "/",
+                        "CSV columns do not match the versioned flat contract.",
+                    )
+                ]
+            rows = list(reader)
+    except (OSError, UnicodeError, csv.Error):
+        return [
+            ValidationIssue("csv_read", "/", "CSV template could not be read safely.")
+        ]
+    if len(rows) != 1 or None in rows[0]:
+        return [
+            ValidationIssue(
+                "csv_example_count",
+                "/",
+                "CSV template must contain exactly one complete synthetic example row.",
+            )
+        ]
+    try:
+        issues.extend(validate_record(_record_from_csv(rows[0])))
+    except (InvalidOperation, KeyError, TypeError, ValueError):
+        issues.append(
+            ValidationIssue(
+                "csv_value",
+                "/",
+                "CSV example contains an invalid typed value.",
+            )
+        )
+    return sorted(set(issues))
+
+
+def _sha256(path: Path) -> str:
+    return hashlib.sha256(path.read_bytes()).hexdigest()
+
+
+def build_corpus_report(root: Path | str = ROOT) -> dict[str, Any]:
+    root = Path(root)
+    manifest_path = root / "test-vectors/manifest.json"
+    manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
+    valid_files = sorted((root / "test-vectors/valid").glob("*.json"))
+    invalid_expectations = manifest.get("invalid", {})
+    unexpected: list[dict[str, str]] = []
+
+    for path in valid_files:
+        try:
+            issues = validate_record(load_record(path))
+        except ValueError:
+            issues = [ValidationIssue("parse_error", "/", "Record could not be parsed.")]
+        if issues:
+            unexpected.append({"file": path.name, "result": "unexpected_invalid"})
+
+    invalid_dir = root / "test-vectors/invalid"
+    for filename, expected_codes in sorted(invalid_expectations.items()):
+        path = invalid_dir / filename
+        try:
+            observed = {issue.code for issue in validate_record(load_record(path))}
+        except ValueError as exc:
+            observed = {str(exc).split(":", maxsplit=1)[0]}
+        if not set(expected_codes).issubset(observed):
+            unexpected.append({"file": filename, "result": "expected_rule_not_observed"})
+
+    csv_issues = validate_csv_template(root / "payment-statement-audit-template.csv")
+    if csv_issues:
+        unexpected.append({"file": "payment-statement-audit-template.csv", "result": "invalid"})
+
+    return {
+        "report_version": "1.0",
+        "validator_version": VALIDATOR_VERSION,
+        "status": "pass" if not unexpected else "fail",
+        "valid_vectors": len(valid_files),
+        "invalid_vectors": len(invalid_expectations),
+        "unexpected_results": len(unexpected),
+        "unexpected": unexpected,
+        "schema_sha256": _sha256(root / "schema/payment-statement-audit.schema.json"),
+        "validator_sha256": _sha256(root / "tools/validate_audit.py"),
+        "jsonschema_version": package_version("jsonschema"),
+        "dependency_versions": {
+            name: package_version(name) for name in VALIDATION_DEPENDENCIES
+        },
+    }
+
+
+def _parse_args(argv: list[str] | None) -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Validate a v1.1.0 Lifted Payments statement-audit JSON record."
+    )
+    parser.add_argument("path", nargs="?", type=Path)
+    parser.add_argument("--json", action="store_true", dest="as_json")
+    parser.add_argument("--corpus", action="store_true")
+    return parser.parse_args(argv)
+
+
+def main(argv: list[str] | None = None) -> int:
+    args = _parse_args(argv)
+    if args.corpus:
+        report = build_corpus_report(ROOT)
+        print(json.dumps(report, indent=2, sort_keys=True))
+        return 0 if report["status"] == "pass" else 1
+    if args.path is None:
+        raise SystemExit("A JSON path is required unless --corpus is used.")
+    try:
+        report = validation_result(load_record(args.path))
+    except (OSError, UnicodeError, ValueError) as exc:
+        code = str(exc).split(":", maxsplit=1)[0]
+        report = {
+            "validator_version": VALIDATOR_VERSION,
+            "status": "invalid",
+            "issue_count": 1,
+            "issues": [
+                ValidationIssue(
+                    code=code,
+                    path="/",
+                    message="Input could not be parsed as a safe audit record.",
+                ).to_dict()
+            ],
+        }
+    if args.as_json:
+        print(json.dumps(report, indent=2, sort_keys=True))
+    elif report["status"] == "valid":
+        print("VALID: record satisfies the v1.1.0 structural, accounting, and privacy rules.")
+    else:
+        print(f"INVALID: {report['issue_count']} rule violation(s).")
+        for issue in report["issues"]:
+            print(f"- {issue['code']} at {issue['path']}: {issue['message']}")
+    return 0 if report["status"] == "valid" else 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

validation-report.json

@@ -0,0 +1,19 @@
+{
+  "dependency_versions": {
+    "attrs": "26.1.0",
+    "jsonschema": "4.26.0",
+    "jsonschema-specifications": "2025.9.1",
+    "referencing": "0.37.0",
+    "rpds-py": "2026.6.3"
+  },
+  "invalid_vectors": 13,
+  "jsonschema_version": "4.26.0",
+  "report_version": "1.0",
+  "schema_sha256": "5979ec9c587be20ae723879f3863edb1f5a78ccddc848ca9a183b58532271730",
+  "status": "pass",
+  "unexpected": [],
+  "unexpected_results": 0,
+  "valid_vectors": 2,
+  "validator_sha256": "876cc506196772369a5b2afcc2e8f72e072268db1cdf61dea0978ea81ae27b0b",
+  "validator_version": "1.1.0"
+}