Run one indexer loop per configured network

[Miracle656]

Background

startIndexer() runs a single loop with module-global state (totalIndexed, pollCycleCount, startedAt) and resolves one set of watched contracts. Depends on W070 (network column) and W071 (per-network RPC). To index both networks in one process, the loop must run once per network with isolated state and its own RPC + watch-list + passphrase.

What to build

Parameterize the indexer by network and launch one loop instance per configured network.

Key files

• src/indexer.ts — startIndexer() (206-286), resolveSacContractIds() (51-71), DEFAULT_XLM_SAC_MAINNET/TESTNET (35-38)
• src/ingester/nft.ts — passphrase selection (122-124)

Suggested execution

git checkout -b feat/multi-network-indexer

1. Make startIndexer(network) take a network; move per-loop counters into local state
2. Use getRpc(network) (W071) and the network's passphrase (Networks.PUBLIC/TESTNET)
3. Read the enabled networks from env (e.g. NETWORKS=testnet,mainnet) and start a loop for each
4. Ensure writes tag network (W070)

Acceptance criteria

• Two loops run concurrently without shared mutable state
• Each writes rows tagged with its own network
• /status reports per-network progress
• Single-network mode still works when only one is enabled

Drips Wave · Complexity: Advanced · 200 points

---

Required: Before submitting, join the contributor Telegram so your work can be tracked and counted toward the Stellar Wave: https://t.me/+fxHXq8f1SwlkZDBk

[Tobore2000]

@Tobore2000 has applied to work on this issue as part of the Stellar Wave Program's 8th wave.

please assign this issue to me

ℹ️ Repo Maintainers: To accept this application, review their application or assign @Tobore2000 to this issue.

[ibochielizabeth-spec]

@ibochielizabeth-spec has applied to work on this issue as part of the Stellar Wave Program's 8th wave.

I’m interested in working on Issue #161 because Wraith needs isolated indexer processes for each configured Stellar network. A single loop with shared module-level state is not suitable for running testnet and mainnet concurrently.

I will first review startIndexer() and the existing RPC, network, contract watch-list, and passphrase logic. I will then parameterize the indexer with a network argument and move loop-specific state such as totalIndexed, pollCycleCount, and startedAt into the individual indexer instance.

Each loop will use its network-specific RPC through getRpc(network), the correct Stellar network passphrase, and the appropriate SAC/NFT watch-list. I will also ensure database writes are tagged with the correct network so testnet and mainnet records remain clearly separated.

I will update the startup logic to read the configured networks from the environment and launch one indexer loop per enabled network. The loops will run concurrently while maintaining completely independent state.

I will also update /status so progress can be reported separately for each network rather than combining their metrics.

Finally, I will test both dual-network and single-network configurations, verifying that two loops can run simultaneously without shared mutable state and that existing single-network deployments continue to work correctly.

The goal is to provide Wraith with a reliable multi-network indexing architecture while keeping network data, RPC connections, configuration, and progress completely isolated.

ℹ️ Repo Maintainers: To accept this application, review their application or assign @ibochielizabeth-spec to this issue.

[collinsezedike]

@collinsezedike has applied to work on this issue as part of the Stellar Wave Program's 8th wave.

GM @Miracle656, let me help you with this issue.

Module-global counters like totalIndexed and pollCycleCount work fine for one loop, but the moment two loops run concurrently in the same process, any shared module-level mutable variable becomes a race condition, two networks writing to the same counter produces numbers that belong to neither accurately. /status reporting per-network progress is impossible unless the state was genuinely separated per network from the start, not just closed over by convention.

Here's my plan:

• Parameterize startIndexer(network) and move totalIndexed, pollCycleCount, startedAt from module-global scope into a per-call local state object (or a state map keyed by network at the module level), so each loop instance owns its own counters with zero shared mutable state between them
• Wire getRpc(network) from W071 and select the correct passphrase (Networks.PUBLIC/TESTNET) per loop instance, replacing the single hardcoded RPC/passphrase path
• Update resolveSacContractIds() and the DEFAULT_XLM_SAC_MAINNET/TESTNET constants to resolve per the loop's own network rather than assuming one global default
• Fix the passphrase selection in nft.ts:122-124 to use the loop's network parameter
• Read NETWORKS=testnet,mainnet from env, splitting and starting one startIndexer(network) call per configured network, confirming single-network mode still works correctly when only one is listed
• Ensure every DB write tags the network column (W070) using the loop's own network, not a global default
• Update /status to report progress per network, reading from the now-isolated per-network state
• Tests: two loops running concurrently produce correct independent counters with no cross-contamination, writes are correctly tagged per network, and single-network mode behaves identically to the current implementation

Happy to start as soon as I'm assigned.

ℹ️ Repo Maintainers: To accept this application, review their application or assign @collinsezedike to this issue.

[Salmatcre8]

@Salmatcre8 has applied to work on this issue as part of the Stellar Wave Program's 8th wave.

I’d like to claim this issue. Refactoring startIndexer() to instantiate isolated, parameterized loop runners per configured network is essential to enable simultaneous multi-network indexing without state collisions or cross-network data pollution.

My implementation plan:

Encapsulate Indexer Loop State (src/indexer.ts): Transition module-level globals (totalIndexed, pollCycleCount, startedAt, lastLedger) into an instantiated NetworkIndexerSession class or context object keyed per network (mainnet, testnet).

Dynamic Configuration & Network Resolution:

Parse enabled targets from NETWORKS (e.g., NETWORKS=testnet,mainnet or single-network fallback NETWORKS=testnet).

Resolve network-specific RPC clients (getRpc(network) from W071), Stellar network passphrases (Networks.PUBLIC / Networks.TESTNET), and contract watchlists (resolveSacContractIds(network)).

Concurrent Multi-Loop Spawning: Spawn independent, concurrent ingestion workers via Promise.allSettled() / async runners, ensuring persistence operations pass the network identifier down to ingestion reducers (src/ingester/nft.ts tagging network per W070).

Per-Network /status Endpoint Aggregation: Update the health/status endpoint to return structured, per-network progress blocks (e.g., status[network]: { currentLedger, totalIndexed, pollCycleCount, uptime }).

Concurrency & Isolation Tests: Add integration tests asserting concurrent multi-network loop execution, verifying that testnet and mainnet writes write to their respective network-tagged rows without state leakage.

Please assign this to me!

ℹ️ Repo Maintainers: To accept this application, review their application or assign @Salmatcre8 to this issue.

[drips-wave]

Congratulations, @Salmatcre8! 🎉 Your application was accepted by the repo's maintainers, and the issue is due on August 31, 2026.

🧑‍💻 @Salmatcre8: Please resolve the issue such that the repo's maintainers have enough time to review your contribution before the due date. You'll earn Points for completing the issue on-time, which will make you eligible for a share of the Stellar Wave Program's reward pool.

Warning

When opening a PR, please link it to this issue to ensure it gets tracked accurately. Points are awarded when this issue is marked as completed by the maintainer.

🤠 Repo maintainers: Please keep an eye on the contributor's progress and review their work before the due date. You can manage this issue, including adjusting its complexity and points, here.

🌊 Happy Wave 🌊