v1.5.0

perf(ui): load validator and pool state in bulk, persist the query cache

TCE-23's fix was incomplete, and this is my own gate. release.yml gained a
`test` job so a tag could not produce a signed, SLSA-attested artifact without
tests running. It runs `pytest tests` with a floor of 15 executed -- but with
no `env:` block and no Falcon library build step.

So on a release tag every lib-gated test SKIPS, and the floor is satisfied
entirely by tests that touch no cryptography. Measured on this machine:

  tests executed (old floor of 15): 59  -> OLD gate PASSES, signs the release
  crypto tests skipped:             12

A gate that passes while the thing it exists to check did not run is the exact
defect class this repo's register documents, and it was sitting in the fix for
a previous instance of it.

Now mirrors ci.yml's signature-kat job: fetch the pinned Falcon source
(ce15e75, the commit go-algorand vendors), assert the pinned-build digest and
the emulated FP backend, build the shared library, then run the suite with
TRELYAN_REQUIRE_KAT=1 and grep the log for the skip marker.

Keeps the 15-test floor AND adds the skip check, because they catch different
things: the floor catches a suite that silently shrank, the grep catches a
suite that ran without the crypto. The floor alone was satisfied by a run in
which every Falcon test skipped, which is how this survived.

A release must not be held to a weaker standard than a pull request.

Verified both directions on a lib-less run: 59 executed clears the old floor,
12 skip markers trip the new guard.

HIGH. `falcon_det1024_verify_compressed` takes NO pubkey length parameter:
deterministic.c calls falcon_verify(..., pubkey, FALCON_DET1024_PUBKEY_SIZE,
...), so it reads exactly 1793 bytes from that pointer regardless of what the
caller allocated. `sig` and `message` are length-delimited and bounded; pubkey
alone was not.

FalconDet1024.verify() passed pubkey straight through as a bare c_char_p with
no check, so a shorter buffer read up to 1729 bytes past the end. Reachable
from the shipped public API -- trelyan_pq.verify is exported from __init__ --
so a verifier reading a pubkey from an arbitrary box or file could crash, or
compute a verdict partly from unrelated adjacent heap memory.

Proved with a guard page (two pages, only the first committed, payload flush
against the boundary):

  full 1793-byte pubkey -> returns cleanly, reads exactly 1793
  1792-byte pubkey      -> ACCESS VIOLATION at the first byte past the buffer
  64-byte pubkey        -> ACCESS VIOLATION

The one-byte-short case is the one that matters: it is the realistic
truncation. Reaching it needs no valid signature -- junk bytes with the right
two header values get there.

The asymmetry is what marks it an oversight rather than a decision: sign() has
always checked len(privkey) != PRIVKEY_SIZE. verify() checked nothing.

WHY NOTHING CAUGHT IT, which is the part worth keeping:

  * tests/fuzz/fuzz_falcon_verify.cc (C/ASan, 13.8M execs) DOCUMENTS this exact
    invariant and honours it -- it always hands the function a fixed 1793-byte
    buffer, and its comment calls a smaller one "a caller-side over-read -- a
    harness bug, not a finding". Correct, and it means that harness could never
    surface this by construction.
  * tests/fuzz/fuzz_encoding_atheris.py DID feed short pubkeys and asserted
    verify() "must return False, not raise" -- an assertion the code could not
    satisfy, because it crashed instead. That file is referenced by no
    workflow, so it has never run.
  * No test varied pubkey length; the KAT and fuzz suites vary the signature
    only, always with a full-size key.

The invariant was written down in one file, violated in another, and the
harness that would have caught it was never wired up.

Fixed in BOTH copies. contracts/falcon_det1024.py is the one deploy_testnet.py
signs real TestNet inscriptions with, and fixing only the SDK is exactly how
TCE-03's cwd hijack survived its first fix.

Raises rather than returning False, matching sign(): a mis-sized key is a
caller error, not a failed verification, and returning False would let a
truncated key read as "signature invalid". The Atheris harness's contract is
corrected to expect that, with the reason recorded inline.

9 regression tests, none needing the C library so they run everywhere.
Mutation-proved: removing either guard fails all 9. SDK suite 50 -> 59 passed,
19 skipped.

Security impact: closes a memory-safety defect reachable from the public API of
an audit-bound crypto SDK. No protocol, wire-format or on-chain change; the
contract's own ABI already pins committed_pubkey to 1793 bytes, so on-chain
state was never the exposure -- the off-chain verifier path was.