> ## Documentation Index
> Fetch the complete documentation index at: https://docs.walletwall.org/llms.txt
> Use this file to discover all available pages before exploring further.

# WallPrint

> WallPrint turns a WalletWall evaluation into an inspectable disclosure record with a receipt, a portable reference and a public resolver, and states exactly what publication does not prove.

> **WalletWall isn't always right. WallPrint keeps the record.**

**WallPrint** is WalletWall's disclosure record. It connects the [evidence model](https://docs.walletwall.org/mcp/evidence-model.md)
to something people can inspect later: it preserves the evidence references, the assessments, the
limitations, the conflicts, and every correction and supersession needed to understand how a WalletWall
conclusion was reached and how it changed.

WallPrint `0.1` is a WalletWall-defined draft built on WWEP `0.1`. Its contract is published as
[`spec/WALLPRINT.md`](https://github.com/Wallet-Wall/walletwall-copilot/blob/main/spec/WALLPRINT.md).

> [!NOTE]
>
> **AVAILABLE · READ-ONLY · DRAFT CONTRACT**
>
> See [what you can use today](https://docs.walletwall.org/concepts/product-status.md) for every surface side by side.
>
> **WallPrint is not one of the six MCP tools or eleven resources.** It is a contract implemented in the
> same open-source engine package, rendered by the WalletWall canvas in GitHub Copilot from bundled
> synthetic lineages, and served by the public resolver at `walletwall.org/wallprint` for records that
> WalletWall has deliberately published. Calling WalletWall MCP never creates or publishes a WallPrint.

## What a WallPrint represents

A WallPrint is one evaluation of one evidence bundle at one evaluation time, focused on one assertion
(the *focal* claim). It records:

| Section | What it holds |
| - | - |
| Subject | The focal assertion's ID, claim type, temporality and subject identity |
| Snapshot time | The WWEP `evaluatedAt`, exactly as evaluated |
| Evidence | The bundle's digest and one reference, with its digest, to every source, observation, assertion and derivation. Observation payloads stay in the bundle |
| Claims | Every assertion with the evaluation the engine computed for it: support, freshness, finality, authority, limitations, diagnostics, corroboration, conflicts, supersession, dependencies |
| Assessments | WalletWall's assessment, plus any attributed external assessments |
| Provenance | The engine's lineage for the focal assertion |
| Limitations, conflicts, violations | As the engine reported them: never resolved, never cleaned up |
| Versions | The policy, rule and registry versions and digests in force |
| Supersedes | The record it corrects or supersedes, if any, bound to that record's digest |
| Digest | `RFC8785` canonicalization, `SHA-256`, and the digest itself |

The record holds no overall verdict, no lifecycle state, no "superseded by" link and no observation
payload. Every value is a string, a boolean or `null`, and unknown fields are rejected anywhere in it.

### Three dimensions that never collapse

| Dimension | Values | Owned by |
| - | - | - |
| Evidence state | WWEP support states: `ESTABLISHED` … `NOT_ESTABLISHED` | The engine's evaluation. WallPrint defines no evidence state of its own |
| Disclosure lifecycle | `COMMITTED`, `DISCLOSED`, `CORRECTED`, `SUPERSEDED`, `WITHDRAWN` | The record's history: metadata *about* the record |
| Assessments | One attributed entry per assessor and policy | The record |

A `SUPPORTED` claim in a `DISCLOSED` record is valid; so is an `ESTABLISHED` one. Disclosing a record
changes nothing inside it, and a lifecycle event never upgrades or downgrades an evidence state.

### Assessments and disagreement

An assessment records what a named assessor concluded under a named policy at a particular time.

* **WalletWall's own assessment is never supplied by the caller.** It is generated from the focal claim's
  computed support state, attributed to `walletwall-rules` under the claim's policy, and a record whose
  WalletWall assessment differs from its focal claim is invalid.
* **External assessments** (roles `ISSUER`, `UPSTREAM_AUTHORITY`, `INDEPENDENT_REVIEWER`, `OTHER`) are
  recorded as stated, with their evidence references. An `ISSUER` assessment must come from the
  registry's authority for that deployment, and no external assessor may use an identity that reads as
  WalletWall or WallPrint.
* **Disagreement is preserved.** Three assessors can disagree, and all three remain. No field anywhere
  holds an overall or consensus verdict. A record with no external assessment is valid: absence of
  assessment is not a failed assessment.

WallPrint's own wording never uses *verified*, *certified*, *safe*, *solvent*, *compliant*, *audited*,
*approved*, *trusted* or *investment-grade*: WalletWall's verdict is a WWEP support state. An external
assessor's statement is recorded verbatim and attributed. Credential-shaped text is refused in every
field of a record.

## History: corrections, supersessions and withdrawals

Every lifecycle change is an event in an append-only history that is hash-chained per record: an event
that is edited, reordered or dropped is detected as long as a later event follows it. Nothing signs or
anchors the chain, so the newest event can be removed or rewritten without detection.

```mermaid theme={null}
stateDiagram-v2
    accTitle: WallPrint disclosure lifecycle
    accDescr: A record starts COMMITTED. From COMMITTED it can become DISCLOSED, CORRECTED, SUPERSEDED or WITHDRAWN. From DISCLOSED it can become CORRECTED, SUPERSEDED or WITHDRAWN. CORRECTED and SUPERSEDED can only become WITHDRAWN. WITHDRAWN is terminal, and a withdrawn record stays addressable.

    [*] --> COMMITTED
    COMMITTED --> DISCLOSED
    COMMITTED --> CORRECTED
    COMMITTED --> SUPERSEDED
    COMMITTED --> WITHDRAWN
    DISCLOSED --> CORRECTED
    DISCLOSED --> SUPERSEDED
    DISCLOSED --> WITHDRAWN
    CORRECTED --> WITHDRAWN
    SUPERSEDED --> WITHDRAWN
    WITHDRAWN --> [*]

    classDef input fill:#FAF8F3,stroke:#C9A47A,color:#1E1A14,stroke-width:1.5px;
    classDef process fill:#BF4E32,stroke:#8B3120,color:#FAF8F3,stroke-width:1.5px;
    classDef decision fill:#C9A47A,stroke:#8B6F47,color:#1E1A14,stroke-width:1.5px;
    classDef output fill:#E6DED2,stroke:#9A9186,color:#1E1A14,stroke-width:1.5px;
    classDef risk fill:#8B3120,stroke:#1E1A14,color:#FAF8F3,stroke-width:1.5px;

    class COMMITTED input
    class DISCLOSED output
    class CORRECTED,SUPERSEDED decision
    class WITHDRAWN risk
```

* **Correction** creates a *new* record that names its predecessor, binds the predecessor's digest and
  gives a reason. The predecessor gains a `CORRECTED` event; its content, digest and earlier events are
  untouched. Correction is not mutation.
* **Supersession** works the same way and marks the predecessor `SUPERSEDED`. Supersession is not
  deletion.
* **Withdrawal** adds a `WITHDRAWN` event with a reason. The record's identity, bytes, digest and
  assessments stay addressable. Withdrawal is not deletion.

A record has at most one successor, so a history never branches or cycles.

## Integrity: digest, receipt and replay

* **Digest.** The record minus its `digest` field is serialized with RFC 8785 and hashed with SHA-256.
  The same evidence, policies, rules and assessments always give the same digest. UI state, local paths,
  process IDs, the current time and credentials have no place in a record, so they can never affect it.
* **Receipt.** A receipt carries the record ID, canonicalization, digest algorithm, digest, bundle
  digest and versions. Verifying it answers one question: do these disclosed bytes match the committed
  record? It does not establish factual truth, solvency, safety, regulatory compliance, issuer
  endorsement or investment merit.
* **Replay.** Replay re-derives a record from its stored evidence and the engine's registry, policies and
  rules, and reports `REPRODUCED`, `MISMATCH` (with one reason per differing section) or `UNREPLAYABLE`
  (a required historical input is missing or not the committed one). Replay never evaluates historical
  evidence under present-day policy and never fills in missing evidence. `UNREPLAYABLE` is not
  `INCORRECT`.

> [!NOTE]
>
> A valid WallPrint digest demonstrates that a disclosed canonical record matches its committed record.
> It does not, by itself, demonstrate that every factual claim in that record is correct.

## Portable reference

A **portable reference** locates one committed record. It answers which record (the record ID), which
bytes (the committed digest) and which contract version, and optionally which section to open:

```text theme={null}
walletwall://wallprint/<recordId>?reference=0.1&wallprint=0.1&digest=<64 hex characters>[&target=<section>]
```

`target` is one of `record`, `receipt`, `replay`, `history`, `assessments` or `provenance`. The same
reference also has a JSON envelope form. Both are deterministic, with exactly one admitted spelling, and
a reference carries no record content.

**A reference is a locator, not authority.** It carries no signature, names no signer, and becomes no
more authoritative by being printed, shared or scanned as a QR code. A corrected, superseded or
withdrawn record is as valid a target as the current one, and nothing redirects an old reference to a
newer record.

## The public resolver

The public resolver gives a reference a stable HTTPS form on WalletWall's product domain. The HTTPS
form is the same text with `walletwall://wallprint/` replaced by `https://walletwall.org/wallprint/`:

```text theme={null}
https://walletwall.org/wallprint/<recordId>?reference=0.1&wallprint=0.1&digest=<64 hex characters>[&target=<section>]
```

**A resolver locates a disclosure. It does not make that disclosure authoritative.** Every resolved page
carries this statement:

> This page resolves a published WallPrint disclosure. Publication and resolution do not establish
> factual truth, safety, solvency, compliance, or investment merit.

### How a page resolves

The resolver is static files and one page script: no server code, no database, no write endpoint and no
signing. The page reads its own URL, fetches the record's standing and one artifact from the same origin
(without credentials, refusing redirects), and proves the bytes in your browser before it shows anything.

```mermaid theme={null}
flowchart TD
    accTitle: How the public resolver page resolves a reference (simplified)
    accDescr: The page first parses the reference. A malformed reference or an unsupported version ends immediately without contacting the store. Otherwise it reads the record's standing. No standing gives UNAVAILABLE; an unreadable store gives UNREACHABLE. If the artifact is not a disclosure the page can read, the result is NOT_COMPARED. If the digests do not agree, the result is DIGEST_MISMATCH. Only when the bytes prove out is the record rendered as RESOLVED.

    ref["Reference in the page URL"]
    parse{"Parses, with a<br/>supported version?"}
    malformed["MALFORMED_REFERENCE or<br/>UNSUPPORTED_VERSION<br/>store never asked"]
    standing{"Standing published<br/>for this record ID?"}
    unavailable["UNAVAILABLE<br/>record unavailable:<br/>not invalid, not false"]
    unreachable["UNREACHABLE<br/>nothing said about the record"]
    readable{"Artifact is a disclosure<br/>the page can read?"}
    notcompared["NOT_COMPARED<br/>nothing compared, nothing shown"]
    digests{"Canonical bytes, artifact digest<br/>and URL digest agree?"}
    mismatch["DIGEST_MISMATCH<br/>digests printed, no record content"]
    resolved["RESOLVED<br/>record rendered with its standing"]

    ref --> parse
    parse -->|"no"| malformed
    parse -->|"yes"| standing
    standing -->|"no"| unavailable
    standing -->|"store unreadable"| unreachable
    standing -->|"yes"| readable
    readable -->|"no"| notcompared
    readable -->|"yes"| digests
    digests -->|"no"| mismatch
    digests -->|"yes"| resolved

    class ref input;
    class parse,standing,readable,digests decision;
    class malformed,mismatch risk;
    class unavailable,unreachable,notcompared output;
    class resolved security;

    classDef input fill:#FAF8F3,stroke:#C9A47A,color:#1E1A14,stroke-width:1.5px;
    classDef process fill:#BF4E32,stroke:#8B3120,color:#FAF8F3,stroke-width:1.5px;
    classDef decision fill:#C9A47A,stroke:#8B6F47,color:#1E1A14,stroke-width:1.5px;
    classDef output fill:#E6DED2,stroke:#9A9186,color:#1E1A14,stroke-width:1.5px;
    classDef risk fill:#8B3120,stroke:#1E1A14,color:#FAF8F3,stroke-width:1.5px;
    classDef datastore fill:#1E1A14,stroke:#9A9186,color:#FAF8F3,stroke-width:1.5px;
    classDef external fill:#FAF8F3,stroke:#9A9186,color:#1E1A14,stroke-width:1.5px;
    classDef security fill:#1E1A14,stroke:#C9A47A,color:#FAF8F3,stroke-width:1.5px;
```

| Outcome | What it means |
| - | - |
| `RESOLVED` | The bytes prove out: canonical form, and a SHA-256 that matches both the artifact's digest and the URL's. The record is rendered with its standing |
| `UNAVAILABLE` | No record with that ID is published. Not invalid, not false |
| `DIGEST_MISMATCH` | The record is published under other bytes, or the artifact fails its own check. Every digest is printed, no record content is shown, and nothing is called forged |
| `NOT_COMPARED` | The artifact is not a disclosure the page reads, so nothing was compared and nothing is shown |
| `MALFORMED_REFERENCE` | The reference does not parse. The store is never asked, and the input is never echoed |
| `UNSUPPORTED_VERSION` | A reference or WallPrint version this resolver does not resolve. Only `0.1` resolves today |
| `UNREACHABLE` | The store could not be read. Nothing is said about the record |

A resolved page states that the URL's digest covers the record's canonical bytes and nothing else: the
title, registry names and the receipt, replay and diff results carried beside the record are checked for
consistency, not covered. A copy served from any origin other than `walletwall.org` says so. The page
loads no analytics and no third-party resources, stores nothing in your browser, reads no clock and never
redirects.

### The store

| Path under `/wallprint/` | What it is | Caching |
| - | - | - |
| `index.json` | The publication index: one small entry per published record | `max-age=300, must-revalidate` |
| `records/<id>/index.json` | A record's standing: publications, lifecycle ledger, successor, lineage | `max-age=300, must-revalidate` |
| `records/<id>/<digest>.json` | The immutable disclosure: the canonical record and the engine results published with it | `max-age=300, must-revalidate` |
| `wallprint.<hash>.js`, `.css`, fonts, mark | The page's content-hashed assets | immutable |

Record IDs are intentionally public, and
[`https://walletwall.org/wallprint/index.json`](https://walletwall.org/wallprint/index.json) lists every
published record: enumeration of deliberately published disclosures is not a leak. Record files are
revalidated within five minutes, so a newly published record is visible quickly and a not-yet-published
one is never cached as missing for long.

## Publication

Publication is **deliberate, never ambient**. Nothing becomes public because it was generated, and
nothing you do with WalletWall MCP publishes anything.

* WalletWall publishes a record from the engine repository, and it reaches `walletwall.org` through the
  product site's ordinary release. There is no public write endpoint, no search endpoint and no assessor
  import.
* A record is admitted only if it validates, its canonical bytes digest to its digest, every engine
  result carried with it agrees with it, and a privacy gate finds nothing credential-, path-, e-mail-,
  IP-address-, environment- or control-shaped, no URL, and no host name or wallet address outside the
  record's own content.
* Published bytes are immutable: the same disclosure always publishes to the same bytes, and different
  bytes under the same ID and digest are a conflict, never an overwrite. The record's standing only
  extends: events append, a successor is set once, and a rewritten history is refused.
* A corrected, superseded or withdrawn record stays published at its own URL. Its page shows its standing
  and links to the successor as a choice; nothing redirects.

On `walletwall.org`, the resolver page and its store are a pinned build of the open-source resolver in
`walletwall-copilot`. The deployment's CI rebuilds the pinned source commit and compares the bytes, and
synthetic example lineages are test fixtures only: they are never published on the production domain.

## What publication does not prove

> [!WARNING]
>
> A WallPrint, its receipt and its resolution are **not**:
>
> * a certification of truth, safety, solvency, regulatory compliance or audit status;
> * an endorsement by an issuer, a protocol or WalletWall;
> * investment advice or an opinion on investment merit;
> * a custody event, a transaction, or a transaction signature;
> * a signature or attestation of any kind: a digest match proves bytes, not who published them.
>
> WallPrint records how WalletWall assessed the presented evidence, under named policies, at a stated
> time. That assessment can be wrong, and WallPrint exists to keep that visible.

Two further limits follow from having no signatures. The standing is the store's own index: it is
checked against its hash-chained ledger, but an authentic but stale ledger, or a well-formed extension
appended by whoever controls the store, is printed as recorded. And the public page proves bytes and
checks consistency; it does not re-run the engine's record validation, which is the publisher's act.
Within the engine, WallPrint 0.1 keeps its history and evidence store in memory, and it cannot yet record
an evaluation in which a `CONFLICTING` state propagates to a derived claim.

## See WallPrints today

* **In GitHub Copilot:** open the WalletWall canvas with a bundled synthetic lineage, for example
  `{ "wallprint": "corrected" }` or `{ "wallprint": "conflicting-assessors" }`, or with
  `{ "reference": "<portable reference>" }`. See [GitHub Copilot](https://docs.walletwall.org/mcp/github-copilot.md).
* **On the web:** follow a published record's HTTPS reference to `walletwall.org/wallprint`. Records
  appear there only after WalletWall publishes them, and the index lists them.

## WallPrint among WalletWall's other artifacts

WallPrint is one of three report-shaped artifacts WalletWall produces, and the only one that belongs to
the MCP engine. The application's [Readiness Packet](https://docs.walletwall.org/concepts/readiness-packet.md) is a signed snapshot of
one wallet's vault readiness derived from WalletWall's scheduled data; the
[Wallet Risk Report](https://docs.walletwall.org/architecture/wallet-risk-report-model.md) is an unsigned per-wallet composition of
the application's scorers. Neither is a WallPrint. A WallPrint carries no signature or attestation and
certifies nothing; a Readiness Packet is signed, but its issuer signature proves only that WalletWall's
server derived it from its data at the stated time, not that the assessment is correct; the Wallet
Risk Report is unsigned.

> [card] [Evidence Model (WWEP)](https://docs.walletwall.org/mcp/evidence-model.md)
>
> The evaluation a WallPrint freezes, state by state.

> [card] [Privacy & Security](https://docs.walletwall.org/mcp/privacy-security.md)
>
> What publication reveals, what the resolver stores, and what WalletWall receives.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.