Implement Batch Result Submission for Tournaments

[famvilianity-eng]

Title: Add Batch Result Submission API for Tournament Support (v2.0 Prep)

Description: Future tournament support (v2.0) requires submitting multiple match results in one transaction. Implement the oracle API and contract logic to batch result submissions.

Requirements and Context:

• Support submitting results for 10-100 matches in one transaction
• Atomic execution (all or nothing)
• Validate all results before commitment
• Document batch submission limits
• Security: Prevent duplicate submissions in batch

Suggested Execution: feature/batch-result-submission

Implement Changes:

• Add submit_batch_results function to oracle contract
• Implement batch validation logic (no duplicates, valid matches)
• Create batch submission helper in oracle off-chain service
• Add tests for batch edge cases

Test and Commit:

• Unit tests for batch validation
• Test batch size limits (100 max)
• Test duplicate detection
• Test partial failure recovery

Example Commit Message:

feat(oracle): add batch result submission for tournament support

- Implement submit_batch_results with atomic execution
- Add batch validation and duplicate detection
- Document batch size limits (max 100)
- Include comprehensive test coverage

Guidelines:

• Design for extensibility (future: 1000+ batch sizes)
• Document transaction size constraints
• Add metrics for batch success rate

---

[DevMusa001]

I'd like to work on this issue. Batch processing, validation, and transaction safety are areas I enjoy working on, and this feature is a key step toward scalable tournament support while maintaining correctness and reliability.

My understanding is that the primary challenge is ensuring multiple match results can be submitted atomically without introducing inconsistent state. The contract should validate the entire batch before any updates occur, preventing scenarios where duplicate entries, invalid matches, or malformed submissions partially modify state. Since this API will serve as a foundation for larger tournament workloads, extensibility and clear operational limits are also important considerations.

My approach would be to implement submit_batch_results with a validation-first workflow that verifies batch size constraints, match existence, and duplicate submissions before committing any results. On the off-chain side, I'd add a helper for constructing and submitting batches efficiently while keeping the interface flexible for future scaling. I'd also introduce comprehensive test coverage covering maximum batch sizes, duplicate detection, invalid entries, atomic rollback behavior, and partial-failure scenarios to ensure all-or-nothing execution guarantees are preserved.

In addition, I'll document batch limits and transaction-size considerations, and add metrics around batch processing outcomes to support future operational monitoring and optimization.

I'd be happy to take this on and deliver a clean implementation with thorough validation, testing, and documentation.

[grantfox-oss]

🦊 GrantFox — @DevMusa001 has been assigned to this issue as part of the Official Campaign campaign!

Next steps:

1. Open a Pull Request referencing this issue (e.g., Closes #744)
2. Your PR will be reviewed by the StellarCheckMate maintainers

Good luck! Track your progress on GrantFox.