L3+ unflagging

[raulk]

Currently, the ability to spawn L3 subnets and beyond is behind a feature flag. We believe things are mostly working, but there are some loose ends.

Criteria to unflag

Product:

• Message propagation paths reviewed and well-tested, including response paths.
• Make sure everything as battle-tested as it can be: unit tests, integration tests, scenario tests, etc.
• Produce good demos of L3+ features.
• Update documentation.

Loose ends:

• Figure out how to deal with combinations of supply sources across the hierarchy.
• Figure out the relayer story -- can a single relayer support multiple subnets?
• Optimize the addressing scheme, as addresses get larger the deeper we go.

[karlem]

Action Plan for Testing and Improving L2+

1. Integration Tests in Solidity (L3-Level Testing)

   • Write and run integration tests to cover the following scenarios:
     • Happy Path Scenarios:
       • From root to L3. - DONE
       • From L3 to root. - DONE
       • Between sibling L3 nodes. - DONE
     • Failure Scenarios:
       • Errors at the destination. - DONE
       • Errors midway through execution. Not sure this is really an issue.
     • Edge Case Testing:
       • Supply source mismatches. - This should really not be an issue - as the only cross net messages allowed are Call kind. (not trasfers)
       • Non-existent destinations. - DONE
     • Ensure all error cases propagate correctly. - DONE

2. End-to-End Testing with Fendermint

   • Create end-to-end tests that simulate message propagation:
     • From root to L3 and back.
     • From L3 to L3.
     • Verify that errors propagate properly across these paths.

3. Advanced Testing (L4+)

   • Implement Parameterized Testing: Use varied inputs to test subnet paths.
   • Apply Generative Testing (Fuzzing) for L3+ subnets to cover a wide range of scenarios based on randomized inputs.

Continuous Improvement and Atomic PRs

• Optimize path routing.
• Investigate if a relayer can be shared across multiple subnets, and explore relayer batching.
• Focus on small, incremental code improvements (e.g., automatic postbox propagation).
• Submit small, focused pull requests for each improvement to ensure the codebase remains clean and maintainable.