Shortly
In Short
XRPL is supported by a large, mature C++ codebase that powers core blockchain infrastructure. As part of an open-source contribution effort, Neti worked on selected modernization tasks in the public XRPL repository.
The initial goal was to migrate legacy tests from an older internal framework to gtest. In practice, the work required more than mechanical test rewriting. Some tests were tightly coupled to older production modules, the repository was actively evolving, and every contribution had to pass review, CI checks, and maintainer expectations.
Neti contributed to the XRPL codebase by migrating selected tests, analyzing architectural dependencies, investigating intermittent CI behavior, and creating tooling ideas to preserve pull request review feedback for future follow-up.
About the Contribution
This was not a client delivery project. It was an open-source protocol engineering contribution to the XRPL ecosystem.
Neti worked directly inside the public XRPL codebase, contributing through pull requests, code review discussions, CI checks, and maintainer feedback. Beyond async code contributions, our team actively participated in weekly organizational core team syncs and facilitated recurring sessions to align on test migration priorities. The engineering focus centered on modernizing selected parts of the test suite and improving maintainability in a large C++ blockchain repository.
The contribution required understanding of not only the test framework, but also the broader architecture of a mature blockchain codebase: legacy modules, newer library-oriented components, production-code dependencies, CI behavior, and repository workflow.
The Challenge: Test Migration Inside a Mature Blockchain Codebase
The project started with a clear technical goal: migrate selected legacy tests from the older Beast framework to gtest.
However, the migration quickly proved to be more than a mechanical rewrite.
The XRPL repository contained two parallel test areas: older tests in the legacy framework and newer tests built around gtest. The codebase also had multiple modules, including areas tied to older node implementation patterns and newer library-oriented architecture.
That created several challenges:
- some legacy tests depended on older production-code modules;
- moving tests without understanding these dependencies could require changes to production code;
- the repository was actively developed, so migrated tests had to be continuously synchronized with upstream changes;
- CI checks could fail intermittently and then pass again without code changes;
- new compiler and static-analysis checks exposed issues that legacy tests had not surfaced;
- code review discussions had to be managed carefully so migration pull requests did not expand indefinitely.
This made the project a custom blockchain development and protocol engineering challenge, not just a test migration task.
Why This Required Protocol Engineering Judgment
In blockchain infrastructure, tests are not isolated from architecture. They often encode assumptions about consensus behavior, peer discovery, ledger state, networking, data structures, and node operation.
For XRPL, Neti had to understand which tests could be safely migrated and which tests were too tightly coupled to older production modules. Some priority areas depended on legacy implementation details. Migrating them directly would have required production-code changes, which would have increased risk and expanded the scope.
Instead of forcing the migration, Neti helped identify a safer path: prioritize tests that could be migrated without touching sensitive production logic, while leaving deeper architectural dependencies for separate technical decisions.
That distinction mattered. A careless migration could have produced cleaner-looking test folders while creating unnecessary risk in the core blockchain codebase.
What Neti Contributed
1. Legacy Test Migration to gtest
Neti migrated selected legacy tests from the older Beast framework to gtest.
The work included:
- analyzing existing test structure,
- identifying migration-safe modules,
- rewriting selected tests in the new framework,
- synchronizing migrated tests with ongoing upstream changes,
- keeping pull requests focused and reviewable,
- working through maintainer feedback,
- maintaining compatibility with the evolving develop branch.
Several pull requests were merged into the upstream XRPL codebase, showing that the migrated work met the project’s review and integration standards.
2. Dependency Analysis Across Old and New Architecture
During the migration, Neti identified that some legacy tests relied on older production modules connected to the existing node implementation.
This was an important architectural finding. It showed that not every test could be moved safely without understanding the boundary between older daemon-based code and newer library-oriented components.
Neti proposed a comprehensive migration strategy focused on minimizing code modification risks. This approach clearly defined which migration areas were immediately safe and which required broader production-code refactoring before test migration could continue responsibly. This methodology was fully accepted and highly valued by the core team.
3. CI and Repository Reliability Investigation
Working inside an active public repository required close interaction with the project’s continuous integration process.
During the work, Neti identified cases where tests could fail intermittently and then pass again without code changes. This pointed to reliability issues in the CI/test execution process.
Neti investigated this behavior and contributed to the discussion around making CI more stable and predictable for contributors and maintainers.
4. Hidden Issue Discovery During Migration
The move to gtest exposed issues that older test infrastructure had not surfaced clearly.
One example involved integer overflow behavior that became visible under newer compilation and checking conditions. Another issue involved static-analysis coverage, where certain file types were not being checked consistently.
These findings showed that test modernization can uncover more than missing coverage. It can reveal assumptions, blind spots, and long-standing behaviors that mature codebases accumulate over time.
5. Review Traceability Automation
Large repositories often accumulate valuable technical discussions inside pull request comments. Once a pull request is merged, unresolved ideas can become difficult to track.
To address this, Neti created automation that could collect pull request review discussions and convert them into structured issue-style summaries.
The goal was to preserve useful review feedback without allowing migration pull requests to grow beyond scope. This helped create a more maintainable process for capturing future improvement ideas while keeping current pull requests focused.
Results: From Test Migration to Codebase Modernization Support
Neti’s work helped move selected XRPL tests from a legacy framework toward a more modern and maintainable testing setup.
More importantly, the contribution created value beyond the migrated tests themselves.
Key Outcomes
Merged upstream contributions
Neti contributed pull requests that were accepted and merged into the public XRPL codebase.
Safer migration strategy
The team identified which test areas could be migrated safely and which depended on legacy production modules.
Improved understanding of architectural dependencies
The work clarified how legacy tests were coupled to older implementation layers.
CI and test reliability insights
Neti identified intermittent test behavior and helped investigate repository-level CI reliability.
Hidden issue discovery
Migration work exposed issues that older test infrastructure had not surfaced clearly, including compiler/checking and static-analysis coverage gaps.
Review process improvement
Neti created automation to preserve pull request review discussions as structured follow-up items, helping maintainers avoid losing useful feedback after merge.
What Protocol Teams Can Learn From This Contribution
Migrating tests in a blockchain codebase is not only a quality-engineering task. In mature protocol repositories, tests often reflect years of architectural decisions.
Before replacing a legacy test framework, teams need to understand:
- which tests are isolated and safe to migrate;
- which tests depend on old production modules;
- where migration would require production-code refactoring;
- how CI behaves under active development;
- how review feedback should be captured without slowing down delivery;
- whether new tooling exposes hidden assumptions or old defects.
For protocol teams, the lesson is clear: codebase modernization should be treated as blockchain protocol engineering, not just refactoring.
Why Neti Was a Good Fit
Neti’s contribution was not limited to rewriting test cases.
The team worked inside a large, public, actively developed blockchain repository and had to combine C++ engineering, architecture analysis, CI investigation, code review discipline, and contributor-process awareness.
That combination is critical for protocol teams that need external engineering support but cannot afford low-context contributors who require constant supervision.
Neti brought:
- ability to work in complex C++ blockchain codebases,
- understanding of protocol-level dependencies,
- discipline around production-code risk,
- experience with CI and repository workflows,
- proactive engineering mindset,
- ability to contribute through public review processes,
- judgment to avoid expanding scope when deeper architecture decisions were needed.
Modernizing a blockchain protocol codebase?
If your protocol team needs help with C++ blockchain development, test migration, CI reliability, protocol tooling, or large-scale repository modernization, Neti can support you with senior engineers who can work inside complex codebases without requiring constant supervision.
Talk to Neti about protocol engineering support.
