fix(tests): Fix Amsterdam filling after rebase
fix(specs): Fix issues with new ruff + mypy rules after rebase

- bal -> block_access_list; re-add custom rlp encoding for block access list
- bytes to uint
- move away from method-style

- Update EIP-7928 implementation: system contracts at index 0, migrate to RLP
  - System contracts (parent hash, beacon root) now use block_access_index 0
  - Transactions use block_access_index 1 to len(transactions)
  - Post-execution changes use block_access_index len(transactions) + 1
  - Migrated from SSZ to RLP encoding as per updated EIP-7928 spec
  - Updated all tests to match new API and structure
  - Replaced tx_index with block_access_index throughout codebase

- add system contract logic
- add markdown docstrings
- update BAL format; address comments
- ssz encoding and bal validation
- six ssz types
- bal tests
- balspecs

fix: do not track setting empty code to a new account (#19)
fix: track implicit SLOAD within SSTORE for OOG cases (#18)
refactor: Put back explicit acct tracking outside 7702 delegation path (#17)
fix non-tracked 7702 authority for invalid delegations (#16)
    * fix non-tracked 7702 authority for invalid delegations
    * fix: lint issues
    * fix: track delegation target when loaded as call target
    * fix: track delegation target when loaded as call target from call
      opcodes
    * chore: fix issues with documentation generation

Fix self-destruct cases with pre-execution balance cache / tracking
    * fix self-destruct implementation
    * fix self-destruct tracking balance
    * fix it in the bal finalization by filtering
    * add balance reset and fix tests
    * simplify pre-balance tracking not using snapshots

fix duplicated code entries for in transaction self destruct
fix self destruct in same transaction bug
fix call/delagate call tracking bug
fix zero-value transfer tracking (#6)
    * fix zero-value transfer tracking
    * fix reverted frame tracking
    * rename variables
    * fix missing addresses bug
    * fix: docs run & move imports to top of file

refactor: move rlp_utils to block_access_lists; bal -> block_access_lists
Some remaining fixes due to large refactor in `forks/osaka`:

- Move BALs from amsterdam -> forks/amsterdam
- rename: build -> build_block_access_list
- fix docc issues

move state change tracker to State

correct system contract addresses

Fixes to communicate with BALs EEST branch:

- fix(bal): Initialize the state tracker before system contract calls

- We were missing system contract calls to beacon roots and history
  contracts. This change initializes the state tracker before system
  contract calls and passes the tracker to these calls if post-Amsterdam.

- fix(docs): Fix issues with toxenvs: lint, doc, json_infra
- fix(t8n): Only initialize the bal_change_tracker for amsterdam
- feat(fork criteria): Index upcoming forks for better ordering / fix issues
- chore(forks): Fix issues from lint after rebase with Osaka latest
- fix(setuptools): Update packages to include amsterdam
- chore(lint): Fix 'tox -e static' issues

- Fix bug in tracker
  Manually cherry-picked from e72991b
  Author: nerolation

- chore(tests): Attempt to resolve issues with CI tests
- chore(lint): fix issues from running ``tox -e static`` locally
- refactor(bal): Send BAL as a list over t8n tool
- fix(amsterdam): Add change tracker to state test in t8n
- chore(lint,tests): Fix tests after moving bal from osaka -> amsterdam
- chore(forks): Move bals from Osaka to Amsterdam
- chore(lint): Fix lint issues

- refactor(bal): Send the full bal object and bal_hash over t8n

  - If we send the full object over JSON, we can model_validate() on ESST.
  - If we send the hash, once we fill the pydantic model, we can get the rlp
    and the hash and validate that our objects match while only really
    validating the parts of the BAL we are interested in for each test.

- chore: point to working eest branch
- chore(bals): Remove unused SSZ utils.py
  The SSZ implementation is no longer needed as we are now using RLP
- refactor(bals): Clean up BAL module types and imports
  - Bytes -> Bytes32 type for storage slots
  - Remove unused imports / fix imports / fix linting
  - Update function signatures to match tracker

- fix(bals-tx-index): Track bal indexes in t8n
  Keep track of BAL index state in t8n

* chore(docs): add `docs-spec-fast` target

`just docs-spec` re-renders every fork-pair diff and takes ~13–18 minutes,
which makes iterating on the docc plugin painful. The plugin already
honors a `DOCC_SKIP_DIFFS` environment variable that skips the diff
discovery step entirely.

Add a `docs-spec-fast` recipe that sets that variable and writes to a
separate `docs-spec-fast` output directory so it does not stomp the full
build output.

* feat(doc): sort `src/ethereum/forks/` listing in fork order

The diff directory listing now renders in fork chronological order, but
the source listing at \`src/ethereum/forks/index.html\` still rendered
forks alphabetically (\`amsterdam\`, \`arrow_glacier\`, ..., \`byzantium\`,
\`cancun\`, ...). The same chronological ordering is more useful here.

Compute a \`fork_order\` map in \`EthereumListingDiscover.__init__\` from
\`Hardfork.discover()\` and add a third branch in \`_listing_source\` that
wraps any parent path matching \`src/ethereum/forks/<fork>\` with an
\`_EthereumSort\` keyed by that fork's chronological index. The existing
\`_EthereumListingSource\` propagation branch carries the key upward
through the parent chain, exactly as it already does for diff sources.

Verified by building with \`just docs-spec-fast\` and inspecting the
rendered listing: forks now render in order \`frontier\`, \`homestead\`,
\`dao_fork\`, \`tangerine_whistle\`, \`spurious_dragon\`, ..., \`amsterdam\`.

* refactor(doc): replace `_EthereumSort` with a path-driven plain tuple

The `_EthereumListingSource` wrapping previously propagated upward
through every parent of every wrapped descendant, so an `_EthereumSort`
key could end up sibling to a plain `ListingSource` whose key contains a
raw `PurePath`. Mixed-type tuple comparison forced `_EthereumSort` to
ship a custom `__lt__(PurePath)` branch, `@total_ordering`, and the
`_typeshed` `SupportsDunderGT`/`SupportsDunderLT` typing dance.

Drive the wrapping decision purely from the parent path instead. Wrap
exactly when `parent` is `diffs/<fork>` or `src/ethereum/forks/<fork>`,
i.e. precisely the listings whose siblings we want to render in fork
order. Every other listing falls through to the default plain
`ListingSource`, so siblings at every level are now homogeneous in key
shape and the mixed-type comparison never occurs. The key collapses to a
plain `(int, PurePath)` tuple sorted by Python's built-in tuple
comparison.

Drop `_EthereumSort`, the `@total_ordering` decorator, and the
`if TYPE_CHECKING: from _typeshed import ...` block. Also drop the
`_sort` field threaded through `DiffSource`: the fork order now comes
from a single `fork_order` map computed once in
`EthereumListingDiscover.__init__` and looked up by path component.
Trim the matching vulture whitelist entries.

Verified with `just docs-spec`: both `diffs/index.html` and
`src/ethereum/forks/index.html` render in chronological fork order
(`frontier`, `homestead`, `dao_fork`, ..., `bpo5`, `amsterdam`).

* factor out some paths, use is_relative_to

* refactor justfile

---------

Co-authored-by: Sam Wilson <sam@binarycake.ca>