Apply fork patches v0.14.2

.cargo/config.toml

@@ -2,11 +2,3 @@
 LLVM_SYS_191_PREFIX = "/usr/lib/llvm-19/"
 MLIR_SYS_190_PREFIX = "/usr/lib/llvm-19/"
 TABLEGEN_190_PREFIX = "/usr/lib/llvm-19/"
-
-# Use `lld` for linking instead of `ld`, since we run out of memory while linking with `ld` on
-# 16-cores linux machines, see:
-# https://nnethercote.github.io/perf-book/build-configuration.html#linking.
-# TODO(Gilad): remove this once `rust` stabilizes `lld` as the default linker, currently only on nightly:
-# https://github.com/rust-lang/rust/issues/39915#issuecomment-618726211
-[target.'cfg(all(target_os = "linux"))']
-rustflags = ["-Clink-arg=-fuse-ld=lld"]

.claude/CLAUDE.md

@@ -0,0 +1,81 @@
+# CLAUDE.md
+
+## Security Warnings
+
+**CRITICAL**: Never read, modify, or expose secret/credential files:
+- Files: `.env`, `*_secrets.json`, `*keys.json`, Kubernetes `secret.yaml`
+- Patterns: `*secret*`, `*key*.json`, `.env*`
+
+## Project Overview
+
+Starknet sequencer (Apollo) - modular blockchain sequencer in Rust. Components are wrapped in servers (local or remote). Local servers use tokio mpsc channels; remote servers use HTTP with JSON serialization (via hyper). Deployment topology is configured without code changes.
+
+**Tx ingestion**: Gateway → Mempool (+ P2P propagation)
+**Block production**: Consensus Manager orchestrates Batcher (pulls from Mempool + L1 Provider, executes via Blockifier)
+**Finalization**: Batcher commits → Committer (state root) → State Sync
+
+**Crate pattern**: Each component has 3 crates: `apollo_*` (logic), `apollo_*_config`, `apollo_*_types`
+
+**Storage**: Apollo storage (MDBX) for sync, batcher & class manager; RocksDB with Patricia merkle trees for state commitment
+
+## Essential Commands
+
+**Python scripts require the venv**: Run `source sequencer_venv/bin/activate` first.
+
+```bash
+cargo build -p <package>
+SEED=0 cargo test -p <package>
+unset CI && scripts/rust_fmt.sh
+python scripts/run_tests.py --command clippy --changes_only --commit_id HEAD
+python scripts/run_tests.py --command integration --changes_only --include_dependencies --commit_id HEAD
+```
+
+## Git Workflow
+
+Commit format (enforced by commitlint in CI): `scope[,scope2,...]: subject`
+
+- **No type prefix** - don't use `feat:`, `fix:`, etc.
+- **Scope required** - use crate names: `apollo_gateway`, `blockifier`, etc.
+- **Special scopes**: `ci`, `deployment`, `release`, `scripts`, `workspace`, `infra`
+- **Max 100 chars**
+
+Examples:
+```
+apollo_gateway: add transaction validation caching
+apollo_mempool,apollo_batcher: optimize streaming
+ci: update rust toolchain
+```
+
+## Code Conventions
+
+### Project Patterns
+- Types crate has `communication.rs` with Client trait, Request/Response enums
+- Config structs implement `SerializeConfig`
+- Test-only code gated with `#[cfg(any(feature = "testing", test))]`
+- Mock traits use `mockall` with `#[cfg(feature = "testing")]`
+- Metrics use `apollo_metrics` framework
+
+## Common Gotchas
+
+- **Proto rebuild**: `cargo clean -p apollo_protobuf && cargo build -p apollo_protobuf`
+- **Dashboard regen**: `cargo run --bin sequencer_dashboard_generator`
+- **Test isolation**: Use `tempfile::TempDir` for storage paths in tests
+- **Cairo native feature**: When modifying `cairo_native`-gated code, verify with `cargo check -p blockifier --features cairo_native`
+- **CI flaky tests**: `blockifier_reexecution` can fail from transient GCloud network issues (not code-related). `merge-gatekeeper` fails when other checks fail (downstream).
+- **Feature flag removal**: `define_infra_metrics!` and `define_metrics!` macros expand code with `cfg(feature = "testing")`. Crates using these macros MUST keep `testing = []` in Cargo.toml even if it looks unused — `check-cfg` will error otherwise. Grep for macro invocations, not just direct `cfg` checks.
+- **Adding `Copy` derive**: Search the entire codebase for `.clone()` on that type (including tests, other crates). Clippy treats `clone_on_copy` as deny-level in CI.
+
+## Mandatory Practices
+
+### Debugging
+When encountering any bug, test failure, or unexpected behavior: investigate the root cause before proposing fixes. Read error messages, trace the execution path, and form a hypothesis. Do not guess-and-check. If `/systematic-debugging` or `/debugging-wizard` skill is available, invoke it.
+
+### Verification
+Before claiming work is complete, fixed, or passing: run the relevant verification commands fresh and confirm the output. No claims without evidence. "Should work" is not verification. If `/verification-before-completion` skill is available, invoke it.
+
+### Receiving Code Review
+When addressing PR review comments: read the full comment, understand the reviewer's intent, and verify the suggestion is technically correct before implementing. Do not blindly apply feedback — push back if the suggestion would introduce a bug or violate project conventions. If `/receiving-code-review` skill is available, invoke it.
+
+## Code Guidelines
+
+Reusable coding lessons are in `.claude/rules/code-style.md`.

.claude/rules/code-style.md

@@ -0,0 +1,158 @@
+# Code Guidelines
+
+Reusable lessons from code reviews and debugging in this codebase. Update this when a review or debugging session reveals a generalizable pattern.
+
+---
+
+## Naming
+
+### Every name must answer "what is this?"
+- A variable name should be a noun or noun phrase that identifies what it holds — readable without surrounding context
+- The core test: if you see the name on its own line, can you tell what it represents?
+
+### No standalone adjectives
+- Adjectives describe a quality but not the thing itself; always pair with the noun
+- Bad: `pending`, `remaining`, `discovered`, `complete`, `invalid`
+- Good: `pending_futures`, `remaining_channels`, `discovered_channels`, `complete_entries`, `invalid_keys`
+
+### No single-letter variables
+- Single letters carry no meaning outside of trivial closures passed to stdlib combinators
+- Bad: `i`, `s`, `n`, `f` as local variables
+- Good: `channel_offset`, `channel_slots`, `num_items`, `felt_value`
+- Exception: Single-letter closure params where the type and context make the meaning obvious (e.g., `.map(|x| x + 1)`, `.filter(|c| c.is_complete())`)
+
+### No contractions or abbreviations
+- Spell out the full word; the saved keystrokes aren't worth the mental tax on readers
+- Bad: `ch`, `sc`, `futs`, `val`
+- Good: `channel`, `subchannel`, `pending_futures`, `value`
+- Exception: Abbreviations established by the domain (e.g., `tx` for transaction, `addr` for address, `pk` for public key, `ctx` for context, `msg` for message)
+
+### Disambiguate counts from collections
+- When a name represents a count, make that explicit with a prefix (`n_`, `num_`) or suffix (`_count`)
+- Bad: `transactions` (Vec or count?), `total` (total of what?)
+- Good: `num_transactions`, `transaction_count`
+
+### Consistent terminology
+- Use the same term for the same concept across parameters, fields, and documentation
+- If a term is renamed, rename it everywhere — partial migrations create confusion
+
+---
+
+## Documentation
+
+### Match documentation to code identifiers
+- Doc comments should use the exact parameter and field names from the code
+
+### Document semantic meaning, not just types
+- Clarify behavioral details that the type signature doesn't convey
+- For indices: inclusive vs exclusive; for optionals: what `None` means; for ranges: whether bounds are included
+
+---
+
+## Async
+
+### Cancellation safety
+- Be careful with `select!` — understand which futures are cancel-safe
+- Dropped futures may leave shared state in an inconsistent state
+
+---
+
+## Edge Cases
+
+### Treat user-provided values as adversarial
+- Any value deserialized from an HTTP request, query parameter, or other external input must be assumed hostile
+- Trace user-controlled values through the full call graph — can they cause DoS, OOM, panics, or resource exhaustion?
+- Cap allocations derived from user input with hard limits
+
+### Never panic on data reachable from requests
+- Code reachable from HTTP handlers or external input must never use `.unwrap()`, `.expect()`, or unchecked indexing on values derived from that input
+- Reserve panics for compile-time invariants where failure is a programmer bug, not a runtime possibility
+- Return `Result` with a descriptive error variant, or use saturating/capping alternatives
+
+### Prefer defensive arithmetic
+- Use operations that handle edge cases gracefully, even if guards exist
+- Prefer `saturating_sub`, `checked_mul`, etc. over raw arithmetic that could underflow/overflow if guards are later refactored
+
+### Prefer intuitive API semantics over internal convenience
+- Design APIs so callers don't need to know implementation details
+- Avoid requiring callers to do adjustments like `start_index + 1`
+
+### Simplify when defaults add no value
+- If `None` just means a default value, consider using a plain type instead
+- `start_index: u64` with default 0 is simpler than `Option<u64>` where `None` means 0
+
+---
+
+## Brevity
+
+### Inline expressions that save >2 lines
+- Inline expressions where doing so saves more than 2 lines without making the resulting line excessively long
+- Prefer `map_or(default, |x| x + 1)` over `map(|x| x + 1).unwrap_or(default)`
+
+### Inline trivial expressions
+- Avoid separate `let` bindings for trivial expressions like `.clone()` when used immediately
+- Inline directly in function arguments if it doesn't hurt readability
+
+### Check for existing utilities before adding new ones
+- Before writing a local helper function, search the codebase for existing shared utilities
+- If similar code exists in multiple places, extract to a shared module
+
+---
+
+## Comments
+
+### Explain WHY, not WHAT
+- Add comments where the reasoning isn't obvious from context
+- Focus on decisions, constraints, and non-obvious requirements
+
+### No visual separator comments
+- Don't use decorative comment lines to delineate sections (e.g., `// -----------`, `// =========`)
+- Rely on blank lines and module organization for readability
+
+### Document implicit structures
+- When code relies on conventions or layouts, make them explicit
+- Storage layouts, protocol-specific ordering, cryptographic choices
+
+---
+
+## Testing
+
+### Never mask test failures
+- Failing tests indicate real problems; hiding them hides bugs
+- Fix the root cause instead of using `#[ignore]` or similar
+- If a test fails due to stale fixture data, regenerate the fixture — don't ignore the test
+
+### Cover edge cases systematically
+- Test boundary conditions, empty inputs, and failure modes
+- For pagination, test with no items, exactly one page, and partial pages
+
+### Use accurate test names
+- Test names should precisely describe the scenario being verified
+- `test_empty_collection` vs `test_no_new_items` convey different conditions
+
+### Match assertions to fixture guarantees
+- Only assert on data presence when the fixture explicitly guarantees that data exists
+- For structural/protocol tests, verify correctness of whatever data is returned without assuming specific content
+
+### Verify base state before debugging failures
+- When a test fails unexpectedly, first verify the code at HEAD actually compiles and tests pass
+- `git stash && cargo build` to check if the original code even compiles before investigating test logic
+
+---
+
+## Module Organization
+
+### Public entry points first
+- Place public functions at the top of the module, before their private helpers
+- Readers should encounter the high-level orchestration first and drill into details top-down
+
+### Imports at scope top, not inline
+- Place `use` statements at the top of the scope they serve — module-level for module-wide usage, `#[cfg(test)] mod tests` top for test-only usage
+- Never put `use` inside function bodies; hoist to the enclosing module
+- Use short imported names in signatures and bodies, not inline qualified paths like `super::types::Foo`
+
+---
+
+## Lessons
+
+<!-- Add new lessons from code reviews and debugging below. Periodically promote them to a named section above. -->

.claude/settings.json

@@ -0,0 +1,55 @@
+{
+  "permissions": {
+    "deny": [
+      "Read(**/*secret*.json)",
+      "Read(**/*secret*.yaml)",
+      "Read(**/*key*.json)",
+      "Read(**/*key*.yaml)",
+      "Read(**/.env)",
+      "Read(**/.env.*)",
+      "Edit(**/*secret*.json)",
+      "Edit(**/*secret*.yaml)",
+      "Edit(**/*key*.json)",
+      "Edit(**/*key*.yaml)",
+      "Edit(**/.env)",
+      "Edit(**/.env.*)",
+      "Write(**/*secret*.json)",
+      "Write(**/*secret*.yaml)",
+      "Write(**/*key*.json)",
+      "Write(**/*key*.yaml)",
+      "Write(**/.env)",
+      "Write(**/.env.*)"
+    ]
+  },
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if echo \"$CLAUDE_FILE_PATH\" | grep -qE 'secret.*\\.(json|yaml)$|([^a-zA-Z]|^)keys?[^a-zA-Z].*\\.json$|([^a-zA-Z]|^)keys?\\.json$|\\.env(\\.|$)'; then echo 'BLOCKED: Cannot edit sensitive files' && exit 1; fi"
+          }
+        ]
+      },
+      {
+        "matcher": "Write",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if echo \"$CLAUDE_FILE_PATH\" | grep -qE 'secret.*\\.(json|yaml)$|([^a-zA-Z]|^)keys?[^a-zA-Z].*\\.json$|([^a-zA-Z]|^)keys?\\.json$|\\.env(\\.|$)'; then echo 'BLOCKED: Cannot write to sensitive files' && exit 1; fi"
+          }
+        ]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "if echo \"$CLAUDE_BASH_COMMAND\" | grep -qE '(^|&&|;|\\|)\\s*(git|gt) add (-A|--all|\\.(\\s|$))'; then echo 'BLOCKED: Stage specific files instead of git/gt add -A or git/gt add .' && exit 1; fi"
+          }
+        ]
+      }
+    ]
+  }
+}

.config/nextest.toml

@@ -0,0 +1,16 @@
+[profile.default]
+slow-timeout = { period = "60s", terminate-after = 2 }
+
+[test-groups.serialized]
+max-threads = 1
+
+# serialized tests (mostly integration tests)
+[[profile.default.overrides]]
+# TODO(victork): evaluate whether these are indeed required to run sequentially
+filter = '(package(apollo_integration_tests) & kind(test)) | package(apollo_network) | (package(apollo_l1_provider) & kind(test))'
+test-group = 'serialized'
+
+# slow test exception whitelist
+[[profile.default.overrides]]
+filter = 'none()'
+slow-timeout = { period = "120s", terminate-after = 2 }

.cursor/hooks.json

@@ -0,0 +1,15 @@
+{
+  "version": 1,
+  "hooks": {
+    "afterFileEdit": [
+      {
+        "command": "python3 .cursor/hooks/format_after_file_edit.py"
+      }
+    ],
+    "afterTabFileEdit": [
+      {
+        "command": "python3 .cursor/hooks/format_after_file_edit.py"
+      }
+    ]
+  }
+}