Every number here comes from a run.

Each guard was removed from the source, the test that claims to catch it was run, and that run was required to fail.

Status

Nothing is deployed. No factory, vault or ledger address exists on any chain, no transaction has been broadcast, and the repository carries no git remote. ./submission/check asserts all three.

01 / The last run

Numbers, and where each one came from.

tests passed, 0 failed, 0 skipped — on an archive endpoint, where all 83 run

of them against a live BSC mainnet fork, nothing mocked on that path; the other 56 are local

guards removed from the source and watched to fail

stateful invariants, at 256 runs each

The fork registers the factory on the real VaultPortal, launches a real taxed token through Flap’s own launch path, buys on the bonding curve and dispatches real tax through it. Nothing on that path is a mock.

Reproducing it

A=<your BSC archive endpoint>both variables point at it

forge test --no-match-path "test/*mainnet*"56 passed, 0 failed, 0 skipped

BSC_RPC_URL=$A ARCHIVE_RPC=$A forge test83 passed, 0 failed, 0 skipped

Two variables, not one. BSC_RPC_URL chooses the fork, but the three tests in Commission.mainnet.t.sol gate on ARCHIVE_RPC and skip when it is unset. Point only the first at an archive endpoint and the run is 80 passed, 0 failed, 3 skipped — the outcome that looks like a pruned node. Both were pointed at the same Alchemy BSC endpoint for the run above.

And a bare forge test is not the local suite. The fork fixture falls back to a public BSC node when BSC_RPC_URL is unset, so a bare run executes all eight suites against that node rather than the six local ones. The command that runs exactly the 56 is the --no-match-path line above.

The last run / 83 tests, to scale

One bar, divided where the suites divide. The width of each block is its share of the run, so the three that need an archive endpoint are drawn as the three they are.

56local — no endpoint at all
24against a BSC mainnet fork — portal, launch, buy, dispatch, gas, settle, claim
3against the fork as well, and gated on the archive endpoint rather than on the fork variable

Pointing only BSC_RPC_URL at an archive endpoint

80 passed · 0 failed · 3 skipped

The three on the right are Commission.mainnet.t.sol, and they gate on ARCHIVE_RPC rather than on the fork variable. That is the difference between the run reported at the top of this page and the run that looks like a pruned node — and it is why “0 skipped” is a claim about an archive endpoint and about nothing else.

The fork suites need the archive endpoint. Every public BSC node we probed prunes state within about 96 seconds, and a launch this suite performs measures at around 53 seconds — so “0 skipped” is a claim about an archive endpoint and nothing else. Read any page reporting a different total as describing a different run.

For the same reason the fork is not pinned to a block. A run is self-consistent, but two runs are against different chain states, so the numbers are not reproducible across runs. Anyone with an archive node can pin one by setting FORK_BLOCK.

02 / The suites

Eight files, 83 tests.

The two .mainnet suites are the 27 that run against the fork. The other six, 56 tests, run locally with no endpoint at all.

Suite	Tests	What it covers
DustVault.mainnet.t.sol	24	real fork: portal, launch, buy, dispatch, gas, schema, Guardian, settle, claim
DustFactory.t.sol	15	portal boundary, malformed input, launch bounds, Flap schema surface
DustVault.t.sol	14	splits, period isolation, pull paths, reentrancy, solvency
DustLedger.t.sol	10	the mechanism, every gate proven red
Beacon.t.sol	7	guardian-table agreement and upgrade authority
PeriodDos.t.sol	6	empty history, cursor frontier, immutable cadence
Solvency.t.sol	4	stateful invariants over tax, work, settle, claim, withdraw and forced BNB
Commission.mainnet.t.sol	3	where the commission goes, measured on chain

03 / Proven red

Each guard was removed, and the test that claims to catch it was required to fail.

For all twenty-seven: break the source, run the test, require a failure, restore the source, check the tree clean. All twenty-seven went red. The tool, the exact edits and the last run are in the repository, so the claim is reproducible rather than reported.

Recorded weight changed to 1 + balanceOf(msg.sender) / (fee * 100) — i.e. turned into every other behaviour-mining schemered

A single require(DUST.balanceOf(msg.sender) >= fee) added as a friendlier errorred

A red gate proves the test catches that break, and nothing wider.

One of the twenty-seven shows why the distinction matters. “No fee setter exists” was broken by adding setFee(uint256) and the test went red — but that test probes five hard-coded names, so all it ever proved was that it catches a setter called setFee. A setter called anything else walks past it green.

Proven red / one mark per guard

Twenty-seven guards, twenty-seven marks. Each one was removed from the source, the test that claims to catch it was run, and that run was required to fail. All twenty-seven did. The marks carry no order; the longer one is the exception described below it.

The fee-setter gate. Its break went red, but the test probes five hard-coded names, so all it proved was that it catches a setter called setFee. It is now backed by an enumeration of the whole ABI instead — itself proven red three ways.

Twenty-six of these marks are a test catching the break it was pointed at. The twenty-seventh is the reason this page counts them one at a time rather than reporting a percentage: a green suite is not evidence a guard exists, and a red gate is evidence about one break and no wider claim.

That one is now backed by an enumeration of the whole ABI instead, itself proven red three ways: a setter under any name, a fee that creeps inside sweep, and an sstore to the slot. Read the other twenty-six with the same question — what exactly did the break vary?