Skip to main content
Glama
forestrie-verify

forestrie-verify

Official
by forestrie

@forestrie/mcp-verify

Verify a SCITT receipt from a Forestrie transparency log under a trust root you hold. Offline: no backend, no account, no key, no network. An MCP server whose only tools verify and decode receipts.

{
  "mcpServers": {
    "forestrie-verify": {
      "command": "npx",
      "args": ["-y", "@forestrie/mcp-verify"]
    }
  }
}
npx -y @forestrie/mcp-verify demo

Why

Agents act on statements they did not witness being made: a quote, an approval, a tool result, another agent's output. Usually the record of what was said is kept by the party that said it, so nobody downstream can ask "did you really say that, and did you say it to everyone?"

A Forestrie receipt is a proof that a statement was sealed into an append-only transparency log. This package checks that proof against a trust root you hold, in your own process, without contacting Forestrie. With the right root it also answers the harder question: whether the log you were shown is the log everyone else was shown. What transparency adds, where it stops, and what a receipt contains: TRANSPARENCY.md.

Related MCP server: VouchSpec Catalog MCP

What it proves

Tool

Reference verb

What it answers

verify_receipt

forestrie verify

Were these exact payload bytes sequenced at this entry id?

verify_grant_receipt

forestrie verify-grant

Was this grant admitted to this log — i.e. was the signer entitled to write?

verify_self

forestrie verify

Does this package's own release receipt vouch for the bytes it ships?

decode_receipt

forestrie decode-receipt --json

What is actually in this receipt? (Renders the CBOR only. Verifies nothing.)

Every tool is annotated readOnlyHint: true, openWorldHint: false. That is not decoration: it is the machine-readable form of "this tool touches nothing", and an agent can see it without running anything.

Trust roots

You do not ask for "verification". You say which root you trust, and the result says what that root can see:

Root

What you supply

genesis

the forest's genesis document, captured when you registered

known-log-key

a log owner key (keyXy, P-256) or KS256 address (ks256Address) you hold out of band

known-accumulator

a snapshot of the log's peaks, from a chain read

checkpoint-chain

a retained chain of .sth checkpoints, plus genesis or keyXy; delegation limits enforced per link

KS256 (secp256k1) roots verify offline too. An EOA root verifies by ecrecover, from a genesis or a known-log-key with ks256Address. A contract root (a Safe) cannot be checked without a chain read, which this package never makes: pass ks256Attestation, an ERC-1271 record fetched elsewhere (@forestrie/mcp-resolve's fetch_ks256_attestation tool, or forestrie-cli's fetch-ks256-attestation). The result is then valid under the contract's signers at the attested block, and says which block. A 20-byte ks256Address asserts, and does not prove, which log it owns. checkpoint-chain takes ks256Attestation too, with the KS256 genesis for the forest chain id; one attestation covers one delegation certificate, so a Safe that rotated its delegate needs one per certificate: pass them as the ks256Attestations array. Every attestation is reported in the result as used, or unused with a reason; none is silently ignored. checkpoint-chain also enforces each link's delegation limits (mmrStart, mmrEnd, expiresAt): delegation_out_of_range, delegation_expired. Since 0.7.0 a peak attached to a receipt is checked against the leaf and inclusion path rather than trusted (@forestrie/receipt-verify 3.2.0), which closes a hole in the known-accumulator and checkpoint-chain roots. Details: docs/trust-roots.md.

The roots are not ordered by strength. The first two check the operator's signature locally and cannot see a split view. The last two match the peak against an accumulator the operator does not control, and can. Every result answers four questions, sealing, split-view, append-authority and attribution, each ok, failed, or not_answered_by_this_root. The last is a real answer and must reach the user; a client that renders only ok is using this tool wrong.

When each root is the effective choice, why a genesis document fetched at check time is weaker than one kept from registration, what a signature root cannot distinguish, and the demo transcript: docs/trust-roots.md.

You do not have to trust the operator

A receipt means something without assuming the Forestrie operator is honest:

  • A pipe, not a store. Only content hashes enter the log. Your statement and its receipt stay with you, and verification is pure over those bytes, so a check never has to ask the operator for anything.

  • The operator does not hold the authority. A log's root key belongs to the log's owner, and the instance bootstrap key to whoever deployed the forest's contract. The operator's sealer signs checkpoints only for logs that have leased its key, within each lease's MMR range.

  • One published history. Checkpoints are published to the univocity contract, which refuses any that are inconsistent with what it already holds. The accumulator roots above check against that.

An operator can still decline to act, and that is visible: it can refuse admission, withhold data it serves, or stop sealing. It cannot rewrite or fork anchored history, or sign for a log that has not leased its key. Who holds which key, and what an operator can and cannot do: key custody and operator powers.

This package's own provenance

Software provenance is the familiar use case for a transparency log, so this package applies it to itself. Every release registers a small statement (package name, version, git commit) in a Forestrie log and ships the receipt inside the tarball. npx -y @forestrie/mcp-verify verify --self, or the verify_self tool, checks it offline. This complements npm's SLSA provenance; it does not replace it. Today the receipt chains to a log on the public development lane. Details: docs/self-registration.md.

That bundle is also the subject of a worked example: fetching this package's own release receipt from the public lane, verifying it under the bundled key, seeing the documented delegation_invalid under the genesis root, and getting split-view ok from a chain read — end to end in a few seconds, with no account. It lives in @forestrie/mcp-resolve's README, because fetching is that package's job, not this one's.

The verification arithmetic comes from @forestrie/receipt-verify, pinned to an exact version and published and attested separately. The tarball ships src and the frozen conformance vectors it is tested against (fixtures/PROVENANCE.md), so the arithmetic can be re-run rather than taken on trust.

Installing the package pulls in more than a verifier needs. @modelcontextprotocol/sdk brings a web stack, including express, hono, jose, cors and ajv, for HTTP transports this package never uses: it constructs only the stdio transport. The verification core never imports the SDK, and the browser-safety gate enforces that, so importing the package's "." export gives you the arithmetic without any of it.

Bundled resources, and the two calls they make runnable

The tarball ships its fixtures as forestrie://fixtures/… MCP resources, so an agent that holds nothing of its own can run a real verification. Two calls reach a pass from resources alone; both are asserted by test/node/mcp-smoke.test.ts.

A grant receipt at the genesis root — verify_grant_receipt with:

Argument

Resource

receipt

golden/grant-receipt.cbor

committedGrant

golden/committed-grant.cbor (derived from golden/manifest.json at read time)

entryId

the text of golden/entry-id.txt

trust

{root: "genesis", genesis: golden/grant-genesis.cbor}

Result: verify-grant: PASS · root=genesis · sealing ok, split-view not answered at this root, append-authority ok, attribution ok.

A payload receipt at an accumulator root, offline, against a real anchor — verify_receipt with the lane-A bundle (fixtures/lane-a/PROVENANCE.md): a real receipt from a public lane and the accumulator the univocity contract had published for its log at block 46770471, captured by an independent chain read. (That lane's content was reset on 2026-09-20; the bytes still verify, the URLs they came from no longer resolve.)

Argument

Resource

receipt

lane-a/receipt.cbor

payload

lane-a/statement.cose

entryId

the text of lane-a/entry-id.txt

trust

{root: "known-accumulator", accumulator: lane-a/accumulator.cbor}

Result: verify: PASS · root=known-accumulator · sealing ok, split-view ok, append-authority ok, attribution ok, with anchor.matchedPeak set. Unlike the demo's self-derived snapshot, this anchor is the contract's published state, so the split-view answer is evidence as of that block. The same receipt passes under {root: "known-log-key", keyXy: {b64: <text of lane-a/log-key.xy.b64>}} and reports delegation_invalid under {root: "genesis", genesis: lane-a/genesis.cbor}, because its log is a grandchild of the forest root (docs/self-registration.md).

A resource's bytes are passed back as {b64: <the blob>}; a text resource such as lane-a/log-key.xy.b64 is base64 text already, so its text goes in b64 as is. golden/burial/public-key.xy.b64 offers the burial chain's root key the same way, so checkpoint-chain can be driven from resources — to its documented negative verdict, since the burial bundle ships no leaf preimage.

Registry

This server is listed as dev.forestrie/verify in the official MCP registry.

Development

mise install           # node 22.14.0, pnpm 10.6.5
pnpm install
pnpm test              # browser-safe gate + encoding-copy gate + server.json gate + unit tests
pnpm build

Conventions, invariants and the release checklist: AGENTS.md.

Licence

MIT.

Available Tools

3 tools
decode_receiptDecode a receipt to JSONA
Read-onlyIdempotent

Render a COSE receipt's CBOR as JSON — headers, named labels, payload, signature and inclusion proof. NO VERIFICATION is performed: a receipt that decodes cleanly may still be invalid. Mirrors forestrie decode-receipt --json.

Inputs: receipt (required). Returns: tag, payload, inclusion, protected, +3 more

verify_grant_receiptVerify a grant receiptA
Read-onlyIdempotent

Verify a Forestrie grant receipt against the committed grant (Forestrie-Grant COSE Sign1, or raw grant payload CBOR plus an entry id), at a trust rung you choose. Mirrors forestrie verify-grant. This is the tool that answers the append-authority question: the leaf IS the grant.

Inputs: trust (required), receipt (required), committedGrant (required), entryId. Returns: ok, rung, stage, anchor, +5 more

verify_receiptVerify a payload receiptA
Read-onlyIdempotent

Verify a Forestrie receipt against the EXACT registered payload bytes and an entry id, at a trust rung you choose. Mirrors forestrie verify. Offline: no network, no key, no account. Returns both the mechanical stages and the four trust questions.

Inputs: trust (required), entryId (required), payload (required), receipt (required). Returns: ok, rung, stage, anchor, +5 more

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 3 tools

    Disambiguation4/5

    verify_receipt and verify_grant_receipt both perform verification but target different artifact types (regular receipt vs. grant receipt), and the descriptions clarify the distinction. decode_receipt is clearly separate since it only renders CBOR without verification.

    Naming Consistency5/5

    All tool names use snake_case and follow a predictable verb_noun pattern: verify_receipt, verify_grant_receipt, decode_receipt. The longer grant variant remains readable and consistent with the others.

    Tool Count4/5

    Three tools is a focused, well-scoped set for a verification service, with each tool earning its place. It sits at the low end of the typical 3–15 range, so it is slightly thin but still appropriate.

    Completeness4/5

    The server covers the core lifecycle: verifying a standard receipt, verifying a grant receipt, and decoding raw receipt data. Minor gaps exist around batch verification or chain-level checks, but the essential verification surface is present.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      A
      quality
      C
      maintenance
      MCP server for offline verification of signed artifacts — receipts, manifests, and audit bundles. MIT licensed, works without accounts or API calls. Tools: self_test, verify_receipt, verify_bundle, explain_artifact.
      4
      6
      Apache 2.0
    • A
      license
      Not graded
      quality
      B
      maintenance
      Issue and verify signed receipts for agent actions, enabling durable, independently checkable proof of policy decisions. Supports offline verification via get_keyset and verify_receipt tools without an account.
      0
      Inno Setup
    • A
      license
      A
      quality
      B
      maintenance
      Lets an agent verify VSL settlement receipts entirely offline and produce signed triggers authorizing a settlement, with the signing key and endpoint fixed at start-up rather than passed in tool calls. When started with an endpoint and token, it can also request a receipt from an issuer, which is the only tool that touches the network.
      1
      92 PyPI
      Apache 2.0