Financial product development cycle

The financial product development cycle at Rumi Finance is a meticulous and thorough process, setting us apart from competitors in the DeFi space. Our multi-step methodology ensures that each new financial product released meets the highest standards in terms of risk-adjusted performance. This rigorous approach allows us to confidently deliver reliable and efficient financial solutions tailored to the unique needs of the decentralized finance ecosystem.

The following diagram describes our methodology:

Step 1 – Product Definition & Deep Research:

Our quantitative team continuously explores market opportunities through our risk framework and discovery tools. Upon identifying an opportunity, we develop a strategy definition, conduct in-depth research, and document existing resources while listing new resources or tools required. The result is a comprehensive architecture and blueprint to build the strategy.

Step 2 – Data Collection:

Data serves as the foundation for backtesting our strategies. Each protocol and chain has unique data structures and methods for data sourcing.

Not all the data is easily accessible through APIs or On-Chain interfaces, this task normally involves very advanced data sourcing and data validation. As an example, we do exhaustive research on APYs calculations on every protocol as we have found misleading information and a lack of consensus on how to publish APYs and APRs, also Oracle Data is not well documented, we have found out that a protocol can have a smart contract with one oracle while having the same data feed in another smart contract coming from another oracle all while both contracts interacting with each other.

Step 3 – Off-Chain Modeling and Simulation:

With the definition, blueprint, and initial data sources in place, we simulate the strategy off-chain. This step includes modeling the strategy, performing complex mathematical calculations, and simulating the strategy's on-chain behavior off-chain, usually in Jupyter Notebooks. This process allows us to run scenario simulations, backtesting, stress testing, and lay the groundwork for optimizing the strategy.

Example: Leverage Yield Farming Delta Neutral Rebalancing Simulation Testing

Step 4 – Quantitative Optimization:

Using the results of the modeling and off-chain simulation, we identify the parameters that drive the strategy's performance and focus on optimizing them. We perform extensive analysis and scenario simulations to create optimized combinations of parameters, resulting in a set of rules or algorithms for strategy optimization.

Example: Leverage Yield Farming Leverage vs Rebalancing Threshold Optimization

Example: Leverage Yield Farming Adjusted ROI-IL optimization vs Leverage

Step 5 – On-Chain Shadow Forked Network Simulation:

Paper trading in DeFi is challenging due to the lack of exact contract copies and out-of-sync data on test nets. To overcome this, we've built a Shadow Forked Network to mimic a main net and synchronize the smart contracts and oracles our strategy will interact with. This setup allows us to test all contract interactions in conditions identical to the main net, ensuring optimal strategy performance.

In the example below we are running a $100k Pseudo-Delta Neutral Strategy on Alpha Homora or any other leverage yield farming provider, this allows us to measure the performance of the strategy as if it were live, determining any pitfalls, adjusting for performance, and measuring limits such as slippage, max deposits and other factors that might hinder the optimization of the strategy.

Architecture of the Forked Shadow Network

Example: Leverage Yield Farming Shadow Fork On-Chain Simulator on Kibana

Step 6 – On-Chain Dry Run:

After optimizing the strategy for on-chain execution, we create a keeper robot to execute the strategy on the main net using real funds. The dry run testing is logged into our data aggregator pipeline for performance measurement and comparison, allowing us to fine-tune the strategy execution. All the dry run testing is logged into our data aggregator pipeline in ElasticSearch-Kibana so that we can measure and compare the performance.

Step 7 – Readiness Assessment for Launch:

In this phase, we evaluate the previous steps' outcomes, measure dry run performance, document potential pitfalls, and establish rules for executing the strategy. We determine the optimization parameters' accuracy and assess if the strategy is ready for launch in a smart contract.

Step 8 – Smart Contract Development:

Now, the strategy is prepared for smart contract implementation. We define the vault-strategy mix, map interfaces to other protocols and addresses, and plan events for on-chain data consumption by our backend. The development undergoes rigorous testing in both forked and shadow forked networks.

Step 9– Smart Contract Launch:

Finally, the smart contract is deployed on the main net, with governance addresses set and the strategy ready for user interaction through our Web3 interfaces.