Skip to content

Make the corpus carry the postable marking and re-earn it against a node - #22

Merged
ifaouibadi merged 2 commits into
developfrom
parity-postable
Aug 20, 2026
Merged

Make the corpus carry the postable marking and re-earn it against a node#22
ifaouibadi merged 2 commits into
developfrom
parity-postable

Conversation

@ifaouibadi

Copy link
Copy Markdown
Contributor

Makes the corpus carry the postable marking the parity-green definition already
asserted, and re-earns that marking against a node on every run rather than
declaring it once.

What lands

  • Each of the three refused vectors carries postable: false, its error_code,
    the chain rule that refuses it, and its sibling — in the corpus next to the
    vector, so the drift check protects the marking too.
  • The marking is re-measured, in both directions. node-exercise.mjs posts
    the non-postable vectors as well and fails if the node now takes one. Verified
    against a deliberately false marking before it was trusted.
  • ChannelForceProgressTx is pinned in gate.rs two-sidedly: removing the
    exception without a postable vector fails, and adding one without removing the
    exception fails too.
  • One sibling was genuinely missing and was added; the version 2 name update's
    was already committed.
  • Two defects found by using the thing: regenerate.mjs --write had never been
    run and reused one field for a path and its contents, and both generator
    headers documented an invocation that cannot work.

Recorded run, ae_uat 7.3.0-rc8, height 1283414: 38 of 38 postable vectors
accepted, no stale markings, controls all rejected, nothing spent.

Review verdict

Merged, with one ruling on top — the row that kept clause 6 red.

The node's HTTP builder emits a name update's pointer list reversed. Scoring
that as a byte disagreement assumes both implementations built the same
transaction, and they did not. Probed directly: a,o,c comes back c,o,a,
c,o,a comes back a,o,c, o,a,c comes back c,a,o. An involution, not a
canonicalisation — so the endpoint does not preserve pointer order in either
direction and cannot be a reference for that field whichever order is right.

The clause now asks for byte-identity from every tag the node has a builder for
that returns the transaction it was asked for, and that exclusion is earned
mechanically — decode the node's bytes, compare field by field, name the field
that differs. Nothing is excused for being a quirk, and differs still means
same transaction, different bytes.

Also corrects the entry-corpus sentence in the generated matrix: no entry fixture
set is committed, but entry bytes do exist here since the mined corpus landed.

Gate on the merge result

cargo fmt --all -- --check clean · cargo clippy --locked --all-targets -- -D warnings
clean · cargo test --locked 197 passed, 0 failed.

…erts

The parity-green sentence was scoped to the postable set, and the corpus had no
such set. A README describing a marking the artifact does not have is exactly
the drift this crate exists to prevent, so the marking now lives in the corpus
next to the vector it describes, where the drift check protects it too.

Each of the three refused vectors carries its `error_code`, the chain rule that
refuses it, and the sibling that gives its tag an acceptance result. Two have
one; `ChannelForceProgressTx` has none and is a named exception, pinned in both
directions — removing the exception without giving the tag a postable vector
fails, and giving it one without removing the exception fails too. A silent pass
needs someone to delete a line, which is the point.

`channel create, with account delegates` is new: the only sibling the corpus was
actually missing. The `ba_` pointer sibling for the version 2 name update was
already committed, so nothing was added for it.

The scoring moved into `matrix.rs`, beside the definition rather than inside the
script that posts. A non-postable vector leaves the builder half too, for the
reason it left the acceptance half: the node has already said it will not take
that transaction, so asking whether it builds the same bytes scores a
disagreement already recorded as the refusal.

`node-exercise.mjs` now fails in both directions. A postable vector the decoder
refuses fails the clause; a non-postable vector the node accepts fails as a
stale marking, because an exclusion nobody has re-earned is a vector quietly
removed from the measurement.

Two fixes found by using the thing. `regenerate.mjs --write` had never been run:
it reused one field for a path and its contents, so it tried to open a whole
corpus as a filename — the check path never noticed because it only compares.
And both generators' headers documented an invocation that cannot work, since
Node resolves a bare specifier from the importing module's directory; they now
point at the harness that copies them next to the install.
The exclusion the corpus claims is now re-earned on every on-node run instead of
assumed: the non-postable vectors are posted too, and the run fails if the node
takes one. Verified against a deliberately false marking rather than by reading
the branch — marking a plainly acceptable vector non-postable exits non-zero with
the stale-marking message, and the control was reverted afterwards.

38 of 38 postable vectors accepted, no stale markings, controls all rejected.
The new sibling is accepted, which is what gives `ChannelCreateTx` an acceptance
result again.

Clause 6 still scores **not satisfied**, for one row and one reason. Excluding
non-postable vectors from the builder half takes the version-2 name update out of
it, and what remains is the node HTTP endpoint that emits a pointer list
reversed. Our order is the reference sdk's and the node's own decoder accepts it,
so it is an endpoint quirk rather than a wire rule — but the clause asks for
byte-identity from every tag the node builds, and whether a quirk belongs inside
that half is not this harness's call to make.
@github-actions github-actions Bot added the triage Acknowledged, not yet routed label Aug 20, 2026
@github-actions

Copy link
Copy Markdown
Contributor

Thanks for the pull request — it is in the queue and a maintainer will review it.

This repository is maintained on a weekly cadence. Anything opened from outside gets
a human reply within 2 business days; this comment is automation confirming your
pull request landed, and it is not that reply.

What happens next:

  • CI runs on the pull request. Check, Build and Test need to be green before
    review — you can push fixes straight to the same branch.
  • A maintainer reviews it against CONTRIBUTING.md.
  • A change to a package's public API, or a new dependency, needs a maintainer
    decision before it can merge. That is where the call gets made rather than a
    delay, and we will tell you either way instead of leaving it open.

If this is a security fix for an unreported vulnerability, please close it and use
the private channel first
SECURITY.md.
A public pull request describes the flaw to everyone before the fix is released.

@ifaouibadi
ifaouibadi merged commit fc86d2b into develop Aug 20, 2026
6 checks passed
@ifaouibadi
ifaouibadi deleted the parity-postable branch September 2, 2026 21:17
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

triage Acknowledged, not yet routed

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant