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

# make targets

> Every make target: what it runs, whether it needs the network, and who it is for.

For SDK maintainers, indexer operators and the kit's maintainers: find the target that runs the check you need.

Each target runs the same command locally and in CI. A row that says "network" reaches the network; every check
also runs with it unreachable under `OFFLINE=1` (below).

| Target | Runs |
| - | - |
| `make toolchain` | Check the installed toolchains against `pins.toml` |
| `make fetch` | Network: everything every target needs: crates, Go modules, Python packages, the stellar-core package and goldens, container images, driver packages and pipeline sources, all pinned and hash-verified (`scripts/fetch.sh all`). `FETCH_ONLY="PART..."` fetches only the named parts (`scripts/fetch.sh` lists them: `deps`, `core`, `conform-pr`, `drivers`, `driver:DIR`, `wallet-backend`, `lint-sources`, `lint-sources-wb`, `docs`, ...); each CI job names the parts its target needs |
| `make demo` | The one-minute demo: replays an indexer with one planted bug (`go/adapters/demo`) from a plain directory and prints its failures with repro commands; exits 0 when the bug is found |
| `make fetch-replay` | Network, for indexer authors: the build dependencies (Python packages, crates, Go modules) and the pinned SeaweedFS image the replay harness serves the `sep54-s3` input from |
| `make fetch-sdk` | Network, for SDK maintainers: the build dependencies and every public conformance column's driver packages, stellar-core's own decoder among them (`xdrcheck conform fetch --set public`) |
| `make fetch-lint` | Network, for `xdrlint` users: the build dependencies (xdrlint's Go modules among them) and golangci-lint at the pinned version with the xdrlint module plugin |
| `make build` | Build `xdrcheck-corpus`, `xdrcheck-mutate`, `xdrcheck`, the adapters and `xdrlint`, link them into `./bin`, and print the `export PATH=…` line |
| `make release` | `scripts/release.sh all`: build the release archive twice and compare, verify it offline from an empty directory, check the stable/`-next` channel split, pack and check the npm package, and write `dist/SHA256SUMS` and the release provenance ([release.md](https://docs.xdrcheck.dev/guides/maintain-kit.md#release-and-channels)); `VERSION=<MAJOR+1>.0.0-rc.N` builds the `-next` channel (refused while the corpus has no next-protocol entry) |
| `make repo-checks` | Repository checks that need no build: schemas and their examples, corpus data, entry IDs, the field table source and guide claims, the public-tree scan and its history self-test, the documentation site's generated pages (`apps/docs/scripts/generate.py --check`), workflow rules, the results data (`results-check`), the corpus entries the guide cites (`check_guide_entries.py`), the mainnet tier's files (`mainnet-tier-check`), and, when `xdrcheck-corpus` is built, the guide's field table, the coverage report with the golden mirror listing and the corpus index (`--check` of each) |
| `make ci-local` | `scripts/ci/run-local.sh`: the jobs of `.github/workflows/pr.yml` (`TIER=pr`) or `full.yml` (`TIER=full`), or one job and the jobs it needs (`JOB=<id>`), run as on a cold hosted runner: a fresh clone of `SHA` (default `HEAD`) per job, an empty home with only the job's declared fetch parts and artifacts, 2 CPUs and 7 GiB per step, the workflow's run lines as written; writes `summary.md` (result, wall time, fetch time, peak disk per job) under `CI_LOCAL_OUT` (network for the fetch steps) |
| `make verify-static` | `repo-checks`, then `xdrcheck-corpus verify --checks schema,hashes,ids` and `xdrcheck pins check` |
| `make verify-corpus` | `xdrcheck-corpus verify --tier curated --report reports/corpus-verify.json` |
| `make verify-generate` | `xdrcheck-corpus gen --check --list corpus/scenarios/pr.list`, always without network |
| `make test` | Unit tests of every component: `test-rust`, `test-go`, `test-drivers` and `test-cli`; the full CI's unit jobs |
| `make test-rust` | `cargo test --locked --workspace` |
| `make test-go` | `go test` in `go/` and `lint/` |
| `make test-cli` | `scripts/py/check_cli_reference.py`: this page against the built tools' help and `make help` |
| `make test-fast` | The pull-request unit tier: `test-rust-fast`, `test-go-fast`, `test-drivers` and `test-cli` |
| `make test-rust-fast` | Every test `test-rust` runs, the test binaries side by side (`scripts/cargo-test-parallel.sh`): the same build, every binary from its package directory, the documentation tests through `cargo test --doc`; nothing skipped or filtered |
| `make test-go-fast` | `test-go` with `go test -short`: a test that checks `testing.Short()` skips (today only `TestTemplateBuildsInItsOwnModule`, which builds the minimal adapter's template as a module of its own) |
| `make check-adapter-ts` | The TypeScript minimal adapter (`examples/adapter-ts`): installs its pinned dependency, runs its selftest and a full replay |
| `make harness-selftest` | Every seeded-bug indexer is replayed and must land in its documented class |
| `make verify-memory` | The replay harness's memory-bound tests and their negative control |
| `make verify-replay` | The reference adapter on every pinned pre-fix and fixed wallet-backend commit, and on the current one |
| `make verify-replay-pr` | The pull-request CI's form of `verify-replay`: the same script and row-by-row assertions on one input, `REPLAY_PR_INPUT` (default `rpc`, the cheaper one); the full CI runs both inputs |
| `make replay-full` | `scripts/replay-full.sh`: the whole curated corpus against wallet-backend at the pinned current commit, on the `sep54-s3` and `rpc` inputs, into `reports/replay-full/wallet-backend-<input>/`; fails on a harness fault, an entry without a row or anything left behind (its unexpected rows are judged by the findings check); not part of `verify`, about 8 minutes |
| `make replay-etl-known` | `scripts/replay-etl-known.sh`: the corpus entries that declare a stellar-etl replay divergence, against stellar-etl at its pinned commit (`pins.toml`), with `--assert-known`, into `reports/replay-etl-known/stellar-etl-<commit>/`; fails when the run cannot be made, a row is not of the pinned commit or an entry does not show its declared result; a run of the findings check's required set, not part of `verify` |
| `make verify-conformance-js` | The pull-request CI's form of the `conform sdk-regression` assertions: `xdrcheck conform build` of the three JavaScript columns the assertions use, then `xdrcheck conform sdk-regression`, into `reports/conformance/sdk-regression.json`; the `pr`-set matrix around it runs in the full CI (`verify-conformance`) |
| `make verify-conformance-public` | `xdrcheck conform build`, `run` and `check` on the `public` column set into `reports/conformance-public/`; not part of `verify`; `verify-acceptance` runs it before `verify-findings-acceptance` |
| `make sdk-loaders` | The corpus loaders an SDK's own tests use (`packages/go`, `packages/rust`, `packages/python`, `packages/npm`), each tested against this corpus ([use-in-sdk-ci.md](https://docs.xdrcheck.dev/guides/sdk-ci.md) §1) |
| `make sdk-ci-examples` | The Go, Rust and Python SDK CI recipes (`examples/sdk-ci/<lang>`) against the pinned go-stellar-sdk, stellar-xdr and stellar-sdk, offline from the caches `make fetch-sdk` fills; each must equal its committed expected-failure list ([use-in-sdk-ci.md](https://docs.xdrcheck.dev/guides/sdk-ci.md) §2) |
| `make sdk-ci-recipes` | `examples/sdk-ci/check_recipes.py`: each SDK CI recipe (Go, Rust, Python, JavaScript) end to end as an SDK maintainer uses it: a scratch SDK repository holding the pinned SDK's tree and the recipe wired to it, the workflow's own test step, offline; each must pass as committed and fail on a new divergence (`SDKCI_LANGS="go js"` selects languages; [use-in-sdk-ci.md](https://docs.xdrcheck.dev/guides/sdk-ci.md) §2) |
| `make sdk-readiness` | Over the run `make verify-conformance-public` wrote: the readiness table (`readiness.md`, `readiness.json`: which pinned SDK versions decode each protocol's and CAP's shapes) and the scoreboard page (`scoreboard.html`), into the same report directory |
| `make results` | `results-findings`, `results-known-defects`, `results-conformance`, `results-replay` and `results-acceptance`: every file under `evidence/results/` (formats in `evidence/results/README.md`); `RESULTS_CHECK=1` compares each with its sources instead of writing it |
| `make results-conformance` | `scripts/py/results.py conformance`: `evidence/results/conformance-matrix.json` from the runs `make verify-conformance` and `make verify-conformance-public` wrote under `REPORTS` |
| `make results-replay` | `scripts/py/results.py replay`: `evidence/results/replay-summary.json` from the runs of `make replay-full`, `verify-replay`, `replay-etl-known` and `harness-selftest` under `REPORTS` |
| `make results-acceptance` | `scripts/py/results.py acceptance`: `evidence/results/acceptance.json`, one row per acceptance check of `docs/acceptance.md` with the status and reason of the acceptance table `make verify-acceptance` wrote under `REPORTS` (`acceptance.json` beside `acceptance.md`) |
| `make results-known-defects` | `scripts/py/results.py known-defects`: `evidence/results/known-defects.json` from the README's known upstream defects table |
| `make results-prevalence` | `xdrcheck-corpus scan entry-tokens`, then `scripts/py/results.py prevalence`: `evidence/mainnet-scan/entry-prevalence.json`, each corpus entry's rarest shape token and how often it occurs on mainnet, from the scan's token table (`TOKEN_TABLE`, not in the repository) |
| `make results-siblings` | `scripts/py/sibling_matrix.py generate`: `evidence/results/sibling-matrix.json` and `findings/SIBLINGS.md`, each SDK defect class against each SDK family, from the level-resolved runs of `make verify-conformance` and the public set under `REPORTS`; `RESULTS_CHECK=1` compares instead of writing |
| `make results-siblings-refresh` | `scripts/py/sibling_matrix.py refresh`: the sibling matrix's record states and its page from `findings/`, without a run (after a record changes state) |
| `make results-mainnet` | `xdrcheck-corpus mainnet coverage`: `evidence/results/mainnet-coverage.json`, the tier's transaction-level tokens held by the mainnet tier and by the curated corpus; `RESULTS_CHECK=1` compares instead of writing |
| `make results-mainnet-check` | `xdrcheck-corpus mainnet coverage --check`, part of `verify-coverage`: the statement is current with `corpus/mainnet/` and the curated corpus (it moves when an entry adds a token) |
| `make results-siblings-check` | `scripts/py/sibling_matrix.py check` and its tests, part of `repo-checks`: the sibling matrix is consistent with `conformance-matrix.json` and `findings/`, and `findings/SIBLINGS.md` is its rendering |
| `make lint-fixtures` | The linter's seeded-violation fixtures (`go test -json` in `lint/`, into `reports/lint-fixtures.jsonl`) |
| `make lint-docs` | The rule pages under `lint/docs/` match the rule registry and fixtures |
| `make lint-plugin` | The golangci-lint module plugin loads under the pinned golangci-lint |
| `make verify-lint` | `lint-fixtures`, `lint-wallet-backend`, `lint-before-after`, `lint-stellar-etl`, `lint-selftest` |
| `make verify-lint-pr` | The pull-request CI's form of `verify-lint`: `lint-fixtures` and `lint-wallet-backend`; the before/after pairs, stellar-etl and the self-test run in the full CI |
| `make verify-guide` | `xdrcheck-corpus guide-table --check --report reports/guide-table.json` and `guide-claims --check`; with the network (`DOCS=1`, the default when not offline), the documentation site's own checks |
| `make verify-coverage` | `xdrcheck-corpus coverage --check`, and `results-mainnet-check` |
| `make mainnet-fetch` | `xdrcheck-corpus mainnet fetch` (network): the mainnet tier's 6,150 public-lake objects, about 1 GB, into `$XDRCHECK_CACHE/mainnet/`, hash-checked and resumable; a full cache makes no request (also `make fetch FETCH_ONLY=mainnet`; not part of `make fetch`) |
| `make verify-mainnet` | `xdrcheck-corpus mainnet check` from the cache `make mainnet-fetch` filled, offline under `OFFLINE=1`: every part's hash chain to its lake object, its round trip and its cut, and the tier's 15,186 transaction-level tokens recomputed with the scan's emitter (corpus/mainnet (`corpus/mainnet/README.md`)); writes `reports/mainnet-check.tsv`; the full CI's P18 |
| `make mainnet-tier-check` | `scripts/py/check_mainnet_tier.py`, part of `repo-checks`: `corpus/mainnet/tier.json` and every line of `tier.jsonl` against their schemas, the header's sha256 and counts, one line per transaction and each token on one line, the lake keys and the cover order, without the lake objects |
| `make acceptance-report-pr` | `xdrcheck report acceptance reports --full-ci <targets>`: the pull-request CI's table, where a check met on that run whose other runs only the full CI makes (`verify-replay`, `verify-conformance`, `lint-before-after`, `lint-stellar-etl`) is `proven in full CI` |
| `make dist-bin` | `scripts/dist.sh bin`: `dist/xdrcheck-<version>-<os>-<arch>.tar.gz` with `xdrcheck`, `xdrcheck-corpus`, `xdrlint` and the template adapters (Linux) or `xdrlint` (macOS), for each platform of `DIST_PLATFORMS` that builds completely on this machine, then `SHA256SUMS`; `DIST_STRICT=1` fails on one that does not ([release.md §9](https://docs.xdrcheck.dev/guides/maintain-kit.md#9-release-assets-prebuilt-binaries-and-the-pin-helper)) |
| `make dist-image` | `scripts/dist.sh image`: the container image `xdrcheck-dist:<version>` from the release assets in `dist/`, built with the network off and smoke-tested offline (each tool starts, the bundled corpus verifies, the demo replay finds its bug, the minimal adapter passes), then removed unless `KEEP_IMAGE=1` ([release.md §10](https://docs.xdrcheck.dev/guides/maintain-kit.md#10-container-image)) |
| `make release-assets` | `scripts/dist.sh assemble`: `SHA256SUMS` and `xdrcheck-<version>.provenance.json` over every asset of the version in `dist/`, each asset checked against them, then the `dist-image` smoke test; what the release workflow runs last |
| `make action-selftest` | `action/selftest.sh`: the GitHub Action (`action.yml`) run step by step against the release in `dist/`, every mode and failure path, and the workflow examples of [github-action.md](https://docs.xdrcheck.dev/guides/ci.md#github-action) through actionlint |
| `make verify` | Every check at full size, then the run summary table (`acceptance-report`): what the full CI runs besides `make test` |
| `make verify-pr` | What the pull-request CI runs: `verify-static`, `verify-corpus`, `verify-generate`, `test-fast`, `verify-replay-pr`, `verify-conformance-js`, `verify-lint-pr`, `verify-guide`, `verify-coverage`, `verify-findings`, then `acceptance-report-pr` |
| `make fetch-nightly` | Network: what only the nightly jobs need — the public columns' driver packages (`xdrcheck conform fetch --set public`) and the stellar-core test image by digest |
| `make nightly-regenerate` | Nightly: `xdrcheck-corpus gen --check --all`, every scenario, without network |
| `make verify-goldens-nightly` | Nightly: golden agreement with stellar-core's own test binary and the bulk tier across drivers |
| `make mutate-sensitivity` | By hand: `TestMutateSensitivity` with `XDRCHECK_MUTATE_REQUIRE=1`, so `xdrcheck mutate` must re-find the known public findings it is tested on and cannot skip for a missing driver |
| `make nightly-early-warning` | Nightly (N6): stellar-core's `test-lcm-next` goldens at `master` (fetched; network) round-tripped in the oracle; the summary separates `fetch` (network), `layout` (stellar-core moved or renamed its goldens) and `decode` failures, and its `arms` line names the arms stellar-core's XDR submodule has that the pinned definitions lack (`xdrcheck xdr diff`) |
| `make nightly-xdr-watch` | By hand, network: `xdrcheck xdr watch` over stellar-xdr main (every `#ifdef` on), its other branches and open pull requests, the standing `lcm_v3` item and the XDR diffs of pending CAP documents, then `xdrcheck xdr candidates` as a patch; writes `reports-nightly/xdr-watch/` (digests per upcoming protocol, `watch-log.jsonl`, per-source diffs, `candidates.patch`). Findings never fail it |
| `make xdr-ceilings` | `xdrcheck xdr ceilings --write`: rewrite the drivers' sentinel-enum ceilings from the pinned XDR definitions; `make test` fails when they drift |
| `make nightly-refetch` | Nightly, network: `make fetch` into an empty cache, then `xdrcheck pins check`, the golden tree's hashes and `xdrcheck-corpus refetch` |
| `make watch-network` | Nightly, network: `xdrcheck pins check --network`, the Horizon roots of mainnet and testnet and the status page's scheduled maintenances against `pins.toml` ([maintenance.md §5.5](https://docs.xdrcheck.dev/guides/maintain-kit.md)) |
| `make nightly-canary` | Nightly, network: `xdrcheck pins latest` (pins behind the newest upstream release) and canary columns for SDK releases not yet pinned, diffed against the pinned columns; reports drift, fails only when it cannot run ([maintenance.md §5.3](https://docs.xdrcheck.dev/guides/maintain-kit.md)) |
| `make vnext-core` | By hand, network and docker: stellar-core master built with the next-protocol flag, cached by commit; `VNEXT_PLAN=1` prints the plan ([maintenance.md §5.4](https://docs.xdrcheck.dev/guides/maintain-kit.md)) |
| `make maint-selftest` | Offline: `renovate.json`, the canary and the next-protocol build scripts against fixtures |

`make <target> OFFLINE=1` wraps each run step in `scripts/offline-run.sh`. A target that runs `xdrcheck`,
`xdrcheck-corpus` or `xdrcheck-mutate` first brings it up to date (`go build`, `cargo build`; they rebuild only what
changed), so a binary older than its sources never judges a run. A tool given on the command line
(`make verify-findings XDRCHECK=/path/to/xdrcheck`) is used as it is, and a missing one fails with a message naming it;
nothing passes silently. `make help` prints the same targets grouped by who runs them.


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